emem, the verifiable memory protocol for the physical world MCP server
io.github.Vortx-AI/ememVortx-AIstreamable-httpv2.4.6Scanned
Shared, verifiable memory for machines and AI. Encode where data lives; decode with any AI.
18 tools: 14 change things and 4 only read.
- Reads private data · 0
- Reads text others write · 11
- Can send data out · 0
- 7 findings
Tools listed without sign-in. Remote posture
With Anlyon
14 tools here change things. Govern them.
- Anlyon lists the tools and adopts none.
- Each tool you adopt gets approvals and receipts.
- Your agent never holds the key.
A tool your agent calls directly is not routed through Anlyon and is not governed by it. Anlyon Radar only lists and labels, and these labels are the same either way.
What the emem, the verifiable memory protocol for the physical world MCP server can do
The emem, the verifiable memory protocol for the physical world MCP server is published by the GitHub account Vortx-AI. It has 18 tools. It can create or change data (14 tools: emem_entity, emem_recall, emem_memory_token, emem_verify_receipt and 10 more), but cannot delete data. 4 tools only read.
11 tools bring in text other people can write (emem_entity, emem_locate, emem_recall and 8 more).
The fixed checks matched 7 findings (annotation-conflict and tool-shadowing). Each one comes with the text it matched.
Its remote endpoint lists its tools without sign-in, and its tools changed 3 times since Anlyon Radar first saw them.
Last scanned Nov 20, 2026, version 2.4.6.
Tools
Grouped by what each tool does, most consequential first. Open one for its reasons and full description; descriptions are the publisher's own words.
18 tools
Changes things 14Claude Code: ask
emem_askAnswer a free-text question about a real-world location in one call.Reads text others writeNo findings
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
Description, as the server wrote it 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 locate, recall and algorithm chain on the server, and returns one packaged envelope. When to use: Call this when the question is about a specific place and the answer must carry its evidence. Send the question as `q`, with `place`, `cell` or `lat`+`lng`. Over MCP a point answer is a projection. It has `answer`, `direct_answer` (verdict, band, rule, date, limits), `receipt` (cite `receipt.fact_cids`), `place_resolved`, `routed_to`, `context` and `spatial_trace`. It has `model_answer` if you sent `model`, and `_projection`, which names what the projection removed. `research_nearby` holds pointers to signed research conclusions; read them with emem_inferences. POST /v1/ask has more, such as `caveats` and `reasoning`. A past date never gets the newest reading. Send `context.context_id` as `context_id` to continue a thread. For how X changed, use emem_intent did_change or emem_diff. Example arguments: {"q":"is this neighbourhood flood-prone for a flat purchase","place":"Ashok Nagar, Ranchi"}
Annotations the server declares
- destructiveHint: false
- idempotentHint: false
- openWorldHint: true
- readOnlyHint: false
- title: Ask a free-text question about a place
emem_echo_verifyGrade a value that you will emit against the signed fact that your citation cites.No findings
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
- The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
Description, as the server wrote it 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 value in emem. This step catches a transcription error that would otherwise be a silent wrong number. A model can resolve a fact correctly and still type `0.2411` for `0.241103`. No other step in the loop sees this. Memory algebra: the `verify` operation (https://emem.dev/docs/model.html). When to use: Call this immediately before you publish, log or pass on a value from an emem fact. Treat a false `matches` as a stop, not a warning. Use `value_verbatim` from resolve: quote that exact decimal string, then echo-verify the text you emitted. For a due-diligence or compliance record, this gives a signed check for each citation. Then you can state `every cited value was echo-verified`. The tool also accepts a bare cid, so a damaged citation still gets a grade. Example arguments: {"token":"emem:fact:defi.zb572.xoso.zb1ec:4qj3l4mgh7ch5kvxmkqspjdl6y42oqhm42khh3gostccpixkbz5q","claimed_value":"-0.0522"}
Annotations the server declares
- destructiveHint: false
- idempotentHint: true
- openWorldHint: false
- readOnlyHint: true
- title: Check a value against the fact it cites, before you publish it
emem_entityGive a real-world object (a bridge, a farm plot, a river, a named place) one shared identity.Reads text others writeNo findings
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
Description, as the server wrote it 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>`) and a signed receipt that shows how the reference resolved. Two agents that name the same object get the SAME entity_cid. A stable external id (Overture GERS or OSM) decides identity when the responder knows one, so different labels for one object collapse to one id. This stops referential drift: 'the damaged bridge near the river' becomes one thing that every model reasons about. When to use: Call this when a conversation refers to a THING and you need a handle that travels between agents. Anchor it with `place`, `cell` or `lat`+`lng`. Give the `emem:entity:` token to a peer, and the peer gets the same object. Recall at its cell64 to read signed facts. Choose the correct sibling: this tool MINTS or returns an identity. `emem_entity_resolve` finds an identity that an agent registered before, from a fuzzy phrase. `emem_entity_link` records that two names mean one object. Do not use it for an observation (use emem_recall or emem_memory_token) or for a place (use emem_locate). An entity is a thing AT a place. Example arguments: {"label":"Golden Gate Bridge","kind":"bridge","place":"Golden Gate Bridge, San Francisco"}
Annotations the server declares
- destructiveHint: false
- idempotentHint: true
- openWorldHint: true
- readOnlyHint: false
- title: Mint or get a canonical object identity
emem_entity_linkRecord a signed, ATTRIBUTED claim that a label or an external id (GERS, OSM, Wikidata) names an existing object.Reads text others writeNo findings
Why it is in this group
- The name "emem_entity_link" says "link": a word for a change.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
Description, as the server wrote it 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: it changes what other agents resolve. The responder stores it with your key, limits the rate for each key, and weighs it by how many INDEPENDENT keys agree. Every reader sees the binding of one key as the claim of one key, never as the answer. When to use: Call this when you can confirm that two names mean one object, or to attach an authoritative external id. Your key goes on the record. Use `stance: "disputes"` when the binding of another key is wrong. The dispute goes beside it and deletes nothing. A second key on a correct single-key binding is useful by itself. Example arguments: {"entity_token":"emem:entity:0a1b2c3d4e5f60718293","alias":"the north dam"}
Annotations the server declares
- destructiveHint: false
- idempotentHint: true
- openWorldHint: true
- readOnlyHint: false
- title: Attest that a phrasing/id denotes an existing object
emem_find_similarFind the k nearest cells in the corpus by cell embedding or by an inline vector.Reads text others write1 finding
Why it is in this group
- The name "emem_find_similar" says "find": a word for reading.
- The server marks it as not read-only (readOnlyHint: false).
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
Findings
- Warn
The server marks "emem_find_similar" as not read-only (readOnlyHint: false), and its words say it reads.
What this check looks forMatched text
annotations: {"readOnlyHint":false,"destructiveHint":false,"idempotentHint":true,"openWorldHint":true}; The name "emem_find_similar" says "find": a word for reading.
Description, as the server wrote it 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 over the vectors it read. `mode` sets the scoring. cosine is exact fp32. hamming counts sign bits and scans many more cells for the same budget. hamming_then_rerank does both. `k` is 1 to 1000, default 10. The tool ranks only what the corpus holds. When the KEY has no vector, it materializes that one band for the key, signs it, reports it in `materialize_notes`, and tries again. It never materializes neighbours. Thus an empty result means that no attested vector is near, not that no place is similar. When to use: Call this for 'find places like X' or 'where else looks like this', or with an embedding. `key` is a cell64 or `inline:[x,y,...]`. The default band is `geotessera` (the 128-D Tessera foundation embedding). For the 1152-D fusion of 9 years (2017 to 2025), send `band: "geotessera.multi_year"`. Example arguments: {"key":"defi.zb64a.cAzU.zfa27","k":10}
Annotations the server declares
- destructiveHint: false
- idempotentHint: true
- openWorldHint: true
- readOnlyHint: false
- title: k-NN over the corpus by embedding
emem_guard_verdictRun the emem-guard policy checks on text before you send it.2 findings
Why it is in this group
- The description's first verb is "run": a word for a change.
- The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
Findings
- Warn
The description contains "another server", wording about other tools or servers.
What this check looks forMatched text
description: "...enAI moderations body, a tool call from another server), send it unchanged and name its `shape..."
- Warn
The server marks "emem_guard_verdict" read-only (readOnlyHint: true), and its own name, description or input give the class "write".
What this check looks forMatched text
annotations: {"readOnlyHint":true,"destructiveHint":false,"idempotentHint":true,"openWorldHint":false}; The description's first verb is "run": a word for a change.
Description, as the server wrote it 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 that a machine can read: `EMEM-GUARD DENY <CODE> token=<token|-> fix=<fix> leaf=<leaf|->`. The codes are: PROV_SIG (the signature did not verify). PROV_BYTES (the citation resolved to different content). PROV_DRIFT (the reading moved past its band threshold). PROV_VALUE (a stated value does not agree with the cited fact). CLAIM_UNGROUNDED (a measurable claim has no citation; turn it on with claim_gating). `fix` tells you what to do: refresh_token, remove_reference, contact_admin, cite_observation, correct_value. Only a self-hosted guard returns GEO_ZONE and redact_and_retry. This tool is ADVISORY: it blocks nothing. A citation that this responder does not hold is never a denial, because it can be a citation from another responder. Memory algebra: the `verify` operation (https://emem.dev/docs/model.html). When to use: Call it on your draft before you assert something, or on a tool result before you reason on it. Then you can fix a citation that does not resolve. With `claim_gating: true`, it also names measurable claims with no citation, and the band that answers each. For a payload from another framework (CloudEvent, OPA input, OpenAI moderations body, a tool call from another server), send it unchanged and name its `shape`. The default reader reads only `texts`, and a check that read nothing answers allow. To ENFORCE the policy, use emem_guard_selfhost. It returns the procedure for your own node. Example arguments: {"texts":["Lusail ground sits at 2.6 m per emem:fact:defi.zb521.jawI.gOze:f3yr3urkrfwamlemwadulgth2qpw645vi6l6fhtuu4dy5o7onahq"]}
Annotations the server declares
- destructiveHint: false
- idempotentHint: true
- openWorldHint: false
- readOnlyHint: true
- title: Check whether the citations in a draft actually verify
emem_intentState what you want in one typed object and get the answer.Reads text others writeNo findings
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
Description, as the server wrote it 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 runs in the same call: you get results, not a list of calls. type | needs | optional | answers where_is | description | | cell64 for a named place what_is_here | cell OR place | description | what is attested at a location is_like | a, b | | cosine similarity of two cells did_change | cell, band, window | | delta for one band over [start,end] tslots find_like | key | k, filter | nearest cells by embedding confirm | claim, cell | | verdict and the signed facts behind it ask | description | place/cell/lat+lng | free-text question, packaged answer area_over_time | geometry, bbox OR areas; start_date, end_date | index, max_scenes | index of an area for each overpass, with spread and anomaly An unknown or missing `type` returns a `needs_intent_type` envelope with the valid values. It is not a hard error. When to use: Call this when the question matches one of the eight rows and you prefer to state the goal. Otherwise call the primitive. A band at a cell is emem_recall. A region is emem_recall_polygon. A free-text question about a place is emem_ask (type:"ask" sends it there). `window` takes tslots, not dates: get them from emem_trajectory. `areas` puts up to 6 areas on one chart. You can call a tool that this text names but your list does not show, by name, through tools/call. Example arguments: {"type":"did_change","cell":"defi.zb64a.cAzU.zfa27","band":"indices.ndvi","window":[20245,20620]}
Annotations the server declares
- destructiveHint: false
- idempotentHint: false
- openWorldHint: true
- readOnlyHint: false
- title: Intent-routed planner
emem_memory_bundleCombine N (cell, band, tslot?) triples into ONE signed envelope.Reads text others writeNo findings
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
Description, as the server wrote it 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-addressed envelope, and the responder signs the full receipt. The `bundle_token` is `emem:bundle:<bundle_cid>`: one string that cites the full set. Memory algebra: the `merge` operation (https://emem.dev/docs/model.html). When to use: Call this when you must cite several (place, band, date) facts as one handle. You can verify the bundle offline with /v1/verify_receipt. The receipt covers all the cited fact_cids and cells. Use this instead of N calls to `emem_memory_token` when the citation is one thing. An example is "the EUDR baseline for these 8 plots at 2020-12-31". The limit is 256 triples for each call. The answer gives `members` and `resolved`, so you can see a bundle that resolved only in part. Example arguments: {"triples":[{"cell":"defi.zb4d9.pefa.zf619","band":"copdem30m.elevation_mean"},{"cell":"defi.zb493.xoso.zcb6a","band":"indices.ndvi"}],"purpose":"audit baseline 2026"}
Annotations the server declares
- destructiveHint: false
- idempotentHint: true
- openWorldHint: true
- readOnlyHint: false
- title: Compose a signed multi-fact memory bundle
emem_memory_tokenMake a citation handle, `emem:fact:<cell64>:<fact_cid>` (or `:<state_cid>`).No findings
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
- The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
Description, as the server wrote it 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 new description of the fact. The tool checks that both parts are not empty and do not contain the `:` separator. Memory algebra: the `cite` operation (https://emem.dev/docs/model.html). When to use: Call this when you need one string that cites a place and an attested fact across messages, agents or tools. Use `emem_echo_verify` before you publish the value. FOR MANY FACTS, USE emem_memory_bundle. This is a measured result. A token is 83 to 84 characters and 51 LLM tokens. The value it cites is 11 characters and 5.4 tokens on average. Thus N tokens use about 9.5 times the context of the N numbers. A bundle is 38 characters for any N up to 256, and it resolves in one round trip. It costs less than tokens from N=1, and less than the plain values from N=5. Use one token to cite ONE fact that you must verify later. Example arguments: {"cell":"defi.zb493.xoso.zcb6a","fact_cid":"cxjiu7l54ujzrpnekp24n4534yojpue4mprddbvevnqtti3lh5bq"}
Annotations the server declares
- destructiveHint: false
- idempotentHint: true
- openWorldHint: false
- readOnlyHint: true
- title: Compose a memory_token citation handle
emem_recallRead the signed facts at a canonical address (cell64).Reads text others write1 finding
Why it is in this group
- The description's first verb is "read": a word for reading.
- The server marks it as not read-only (readOnlyHint: false).
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
Findings
- Warn
The server marks "emem_recall" as not read-only (readOnlyHint: false), and its words say it reads.
What this check looks forMatched text
annotations: {"readOnlyHint":false,"destructiveHint":false,"idempotentHint":true,"openWorldHint":true}; The description's first verb is "read": a word for reading.
Description, as the server wrote it 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 a fact and verify it again. Resolve the cid anywhere and you get the same bytes. A fact_cid is NOT a fingerprint of the observation. The digest includes the responder's key and the time it signed. Thus two responders that measure the same thing make different fact_cids, and a cid resolves only at the responder that signed it. For identity across responders, use emem_entity. Send `deterministic:true` (or a `provenance` class list) to keep only facts that you can compute from the cited raw source. In the memory algebra this is ensure(cell, bands), not get: you state what must exist. When to use: Call this after `emem_locate`, or with a cell64 or a place name. It returns every Primary fact at that (cell, band, tslot). A band can have no fact but have a materializer. Then the responder fetches the upstream value, signs it, stores it and returns it in the same call. The first call is slow; later calls use the cache. Thus any wired band recalls at any cell on Earth: send `bands: [<band>]`. `materialize_notes` lists what the call fetched. Empty notes mean no materializer here. Example arguments: {"cell":"defi.zb64a.cAzU.zfa27","bands":["weather.temperature_2m","copdem30m.elevation_mean"]}
Annotations the server declares
- destructiveHint: false
- idempotentHint: true
- openWorldHint: true
- readOnlyHint: false
- title: Recall facts at a cell (auto-materializes on miss)
emem_toolsThe map of emem's tools, and the one tool that finds all the others.1 finding
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
- The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
Findings
- Warn
The description contains "every other tool", wording about other tools or servers.
What this check looks forMatched text
description: "...erify, check for drift). Then it groups every other tool by the question it answers, each with a..."
Description, as the server wrote it 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 question it answers, each with a one-line trigger. Send `name` for the full schema of one tool and an example that runs. IF YOU SEE A LIST OF 18 TOOLS, IT IS A CURATED SUBSET OF 119, NOT THE FULL SURFACE. Hosts remove `_meta`, so this text repeats the count. A host that calls only listed tools refuses the rest: connect /mcp/full and follow `nextCursor`, or use `listed_route`. When to use: Call this FIRST when you do not know which tool answers the question. Also call it when your list does not have a capability. A tool that is not in your list can still be on the server. `q` searches by topic (`ndvi`, `flood`, `verify`). `name` returns one exact schema. With no arguments, you get the full map. /mcp/full registers the full catalog. emem_ask answers in one call without a choice of primitive. Example arguments: {"q":"ndvi"}
Annotations the server declares
- destructiveHint: false
- idempotentHint: true
- openWorldHint: false
- readOnlyHint: true
- title: What tools exist here, and when to reach for each
emem_verify_receiptVerify a signed receipt on the server.No findings
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
- The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
Description, as the server wrote it 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. It returns `{valid, reason, failure_detail, signature_valid, merkle_proof_valid, signer_pubkey_b32, preimage_blake3_hex}`. A receipt verifies BYTE FOR BYTE OR NOT AT ALL. Version 2 binds the inclusion proof, so a change of any kind makes the signature fail: a dropped field, a renamed field, a summary. Use this tool when the browser page /verify is not available. Also use it to audit a receipt from a third party. When to use: Send the receipt EXACTLY as the read tool returned it, complete and unchanged. Two omissions cause a false forgery, not a 400. Do not drop `merkle_proof`. Do not drop `preimage_version`. Without it the value is 0, which selects the v0 rule, and the signature reads as invalid. The signature and the key can be byte arrays, or `sig_b32` and `responder_pubkey_b32`. The tool accepts no other names. When a field changed after signing, the answer is `reason: receipt_reshaped_after_signing` and names the field. To require a specific signer, set `pubkey_b32`. A bad signature returns 200 with `valid: false`, never a 4xx. The example (from emem_tools) is a real receipt over two Trafalgar Square facts. Unchanged, it is `valid`. Change one byte, and it is not. Example arguments: 1602 bytes, too long to inline in a listing. Call `emem_tools` with `{"name": "emem_verify_receipt"}` for it whole and runnable; it is not shortened here because a truncated example is not one.
Annotations the server declares
- destructiveHint: false
- idempotentHint: true
- openWorldHint: false
- readOnlyHint: true
- title: Server-side ed25519 receipt verifier
fetchDereference an id from `search`.Reads text others write1 finding
Why it is in this group
- The name "fetch" says "fetch": a word for reading.
- The server marks it as not read-only (readOnlyHint: false).
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
Findings
- Warn
The server marks "fetch" as not read-only (readOnlyHint: false), and its words say it reads.
What this check looks forMatched text
annotations: {"readOnlyHint":false,"destructiveHint":false,"idempotentHint":true,"openWorldHint":true}; The name "fetch" says "fetch": a word for reading.
Description, as the server wrote it 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:` citation, a bare fact_cid, or an `emem:cell:` handle for a full cell. The value is the exact decimal string that the responder signed, never a new format. A fact handle writes nothing. A cell handle, like `emem_recall`, MATERIALIZES a missing band on a cold cell: it fetches, signs and stores it. The flags follow that path: readOnlyHint false. When to use: Call this on each result that you will cite, before you quote the number. Quote the one-line reading. The body lets a reader check it, and emem_echo_verify grades what you emit against it. When a body is too large, the answer says so and gives the URL that serves it complete. Example arguments: {"id":"emem:fact:defi.zb493.xoso.zcb6a:cxjiu7l54ujzrpnekp24n4534yojpue4mprddbvevnqtti3lh5bq"}
Annotations the server declares
- destructiveHint: false
- idempotentHint: true
- openWorldHint: true
- readOnlyHint: false
- title: Open one search result and read the signed record
searchSearch emem's signed corpus and get results as citations.Reads text others write1 finding
Why it is in this group
- The name "search" says "search": a word for reading.
- The server marks it as not read-only (readOnlyHint: false).
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
Findings
- Warn
The server marks "search" as not read-only (readOnlyHint: false), and its words say it reads.
What this check looks forMatched text
annotations: {"readOnlyHint":false,"destructiveHint":false,"idempotentHint":true,"openWorldHint":true}; The name "search" says "search": a word for reading.
Description, as the server wrote it 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 those bytes. The query can be a place or a question about one. ('NDVI near Mount Fuji': a topic word narrows the results and never removes all of them.) It can also be a cell64, an `emem:cell:` handle, or an emem citation, which returns the one fact it cites. The list has a cap for the wire. The first entry (index 0) names the cell and the TRUE total. On a cold cell, the tool MATERIALIZES a missing band first, as `emem_recall` does: it fetches, signs and stores it. Thus readOnlyHint false. When to use: Call this first when a question is about a place and the answer must have citations. It changes the question into a list of sources, and `fetch` expands each source. For one combined answer in one call, use emem_ask. Example arguments: {"query":"Trafalgar Square, London"}
Annotations the server declares
- destructiveHint: false
- idempotentHint: true
- openWorldHint: true
- readOnlyHint: false
- title: Find signed facts for a place, as citable sources
Only reads 4Show 4 read-only tools
emem_entity_resolveFind the objects that agents connected to a phrase.Reads text others writeNo findings
Why it is in this group
- The name "emem_entity_resolve" says "resolve": a word for reading.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
Description, as the server wrote it 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` and `corroboration` (`single_key` | `multiple_independent_keys` | `none_attributed`). `contested` is true when more than one object claims the name. Send `text` for candidates, `near` to narrow by place, or an `emem:entity:` `token` to dereference. The tool only reads. Alias text is data from other agents. When to use: Call this BEFORE you mint and before you cite. Resolve first, and mint only if nothing matches. Read `corroboration` before you cite. A `single_key` binding is the claim of one agent about a shared name. If you can confirm it, corroborate it with emem_entity_link, so the next reader sees two keys. Example arguments: {"text":"the golden gate bridge","near":"San Francisco"}
Annotations the server declares
- destructiveHint: false
- idempotentHint: true
- openWorldHint: true
- readOnlyHint: true
- title: Resolve a phrase (or emem:entity: token) to a canonical object
emem_locateGet the canonical address (cell64) of a real-world place.Reads text others writeNo findings
Why it is in this group
- The description's first verb is "get": a word for reading.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
Description, as the server wrote it 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 algorithms that you can recall there. For an OBJECT identity (a bridge, a plot) instead of a cell, use emem_entity. Send `lat`+`lng` as numbers, or a free-text place. When both arrive, the coordinates win. `q`, `query` and `name` are other names for `place`. The answer lists keys that this schema does not declare in `_unrecognised_arguments`, so a typo is visible. When to use: Call this when the next step needs the cell64 of a named place, or the bands that exist there. `data_at_this_cell` lists every band you can recall, by topic (`live_bands_by_topic`), the recipes that use them (`algorithms_for_topic`), and the bands with no materializer here. It has `research_nearby` when vouched research agents signed conclusions inside the place. Read those with emem_inferences before you recompute them. For one packaged answer in one call, use `emem_ask`. Example arguments: {"place":"Mount Everest"}
Annotations the server declares
- destructiveHint: false
- idempotentHint: true
- openWorldHint: true
- readOnlyHint: true
- title: Resolve place to cell64 + band inventory
emem_memory_contradictionsFind where the corpus DISAGREES with itself (algebra: competing evidence).No findings
Why it is in this group
- The description's first verb is "find": a word for reading.
Description, as the server wrote it 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 disagreement with a severity from 0 to 1 and a citation for each disputed fact. It does not pick one value and hide the conflict. It tells you when not to trust a single answer. Read the SCOPE before you quote a zero. By default it counts two kinds: two DIFFERENT attesters that disagree, and one responder that answers from two upstreams. `disagreement_scope` names the kind. When to use: Call this before you rely on a number: 'do the sources agree on X', 'audit this claim'. Use `cell_prefix` for a region and `band` for one band family. `min_severity` removes small differences. Severity depends on the band kind: for a scalar, the spread over the band's range. For a vector, 1 minus the mean cosine. For a category, 1 minus the share of the mode. On a single-responder node, add `include_same_attester_sources: true`. There, the most likely disagreement is one signer that answers from two providers. Each record names its `disagreement_scope`. The receipt cites every disputed cid. To measure a pair, use `emem_diff`. To read the `disagrees_with` edge, use `emem_edges_recall`. Example arguments: {"cell_prefix":"damO","band":"indices.ndvi","min_severity":0.2}
Annotations the server declares
- destructiveHint: false
- idempotentHint: true
- openWorldHint: false
- readOnlyHint: true
- title: Scan for multi-attester disagreement
emem_memory_token_resolveRead a `emem:fact:<cell64>:<fact_cid>` citation handle and return the reading that it cites.No findings
Why it is in this group
- The name "emem_memory_token_resolve" says "resolve": a word for reading.
Description, as the server wrote it 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. You do not split the token or call `GET /v1/facts/<cid>` yourself. Memory algebra: the `resolve` operation (https://emem.dev/docs/model.html). When to use: Call this when you have a memory_token from another agent or an earlier turn and need the value. For a scalar, quote `value_verbatim`, the exact decimal string that the responder signed. A null `value` or `unit` means the fact has none (an absence, or an index with no unit). It does not mean a missing field. A cid that this responder does not hold returns a typed 404. Then try /v1/fetch, or resolve at a mirror. Example arguments: {"token":"emem:fact:defi.zb493.xoso.zcb6a:cxjiu7l54ujzrpnekp24n4534yojpue4mprddbvevnqtti3lh5bq"}
Annotations the server declares
- destructiveHint: false
- idempotentHint: true
- openWorldHint: false
- readOnlyHint: true
- title: Dereference a memory_token in one round-trip
This is not a safety rating, and no finding is not a safety guarantee. The groups and findings come from fixed checks of the tool definitions the server returned on the date shown, not from its code or what it does when called. How the checks work.
Exfil surface
Which tools read private data, which read text someone else can write, and which can send data out. One of each is a path a prompt injection can use.
No private-data, untrusted-input, outbound path in this server alone: no tool is tagged private-data or outbound.
- Reads private data0
- Reads files, mail, messages, databases, secrets, calendars or repositories.
- Reads text others write11
- Brings in text someone else can write: web pages, inbound email, messages, issues and comments.
- Can send data out0
- Can carry data to people or systems: it sends, posts or publishes, or takes a recipient, channel or URL.
Other servers in the same agent add their own tools to these paths. Audit your whole setup to see them together.
Remote posture
What anyone on the internet sees at the remote endpoint: an anonymous initialize and tools/list, and the public OAuth metadata.
Looked at Nov 20, 2026, 19:01 UTC, unchanged since Oct 22, 2026. No credentials were sent and no tool was called. What is looked at.
- Reachable
- yes
- HTTP status of an anonymous initialize
- 200
- tools/list served without credentials
- yes
- Tools that change things, listed without credentials
- 14
- Protocol version
- 2025-06-18
- WWW-Authenticate on 401
- not observed
- resource_metadata in WWW-Authenticate
- not observed
- RFC 9728 protected resource metadata
- https://emem.dev/.well-known/oauth-protected-resource/mcp
- Authorization servers
- https://emem.dev
- Legacy HTTP+SSE transport
- no
- Dynamic client registration
- yes
- Client ID metadata documents
- no
- WarnThe whole server
The endpoint served tools/list without credentials, and the list has 14 tools that change things (14 write). Whether a call also works without credentials was not tested: tools are never called.
What this check looks forMatched text
https://emem.dev/mcp: tools/list returned 18 tools to an anonymous client, including emem_entity (write), emem_recall (write), emem_memory_token (write), emem_verify_receipt (write), emem_guard_verdict (write) and 9 more
Findings
Matches of fixed checks, with the text they matched.
- Warnemem_recall
The server marks "emem_recall" as not read-only (readOnlyHint: false), and its words say it reads.
What this check looks forMatched text
annotations: {"readOnlyHint":false,"destructiveHint":false,"idempotentHint":true,"openWorldHint":true}; The description's first verb is "read": a word for reading.
The description contains "another server", wording about other tools or servers.
What this check looks forMatched text
description: "...enAI moderations body, a tool call from another server), send it unchanged and name its `shape..."
The server marks "emem_guard_verdict" read-only (readOnlyHint: true), and its own name, description or input give the class "write".
What this check looks forMatched text
annotations: {"readOnlyHint":true,"destructiveHint":false,"idempotentHint":true,"openWorldHint":false}; The description's first verb is "run": a word for a change.
- Warnemem_tools
The description contains "every other tool", wording about other tools or servers.
What this check looks forMatched text
description: "...erify, check for drift). Then it groups every other tool by the question it answers, each with a..."
- Warnsearch
The server marks "search" as not read-only (readOnlyHint: false), and its words say it reads.
What this check looks forMatched text
annotations: {"readOnlyHint":false,"destructiveHint":false,"idempotentHint":true,"openWorldHint":true}; The name "search" says "search": a word for reading.
- Warnfetch
The server marks "fetch" as not read-only (readOnlyHint: false), and its words say it reads.
What this check looks forMatched text
annotations: {"readOnlyHint":false,"destructiveHint":false,"idempotentHint":true,"openWorldHint":true}; The name "fetch" says "fetch": a word for reading.
Show 1 more findingShow fewer
The server marks "emem_find_similar" as not read-only (readOnlyHint: false), and its words say it reads.
What this check looks forMatched text
annotations: {"readOnlyHint":false,"destructiveHint":false,"idempotentHint":true,"openWorldHint":true}; The name "emem_find_similar" says "find": a word for reading.
History
Changes to its tool definitions and to its remote endpoint, newest first.
Tools2 changed.~2 changedView diff
- Changed:emem_askChanges thingsdescriptioninputSchema
- Changed:emem_toolsChanges thingsdescriptioninputSchema
Tools1 changed.~1 changedView diff
- Changed:emem_memory_contradictionsOnly readsdescriptioninputSchema
Tools4 changed.~4 changedView diff
- Changed:emem_askChanges thingsdescription
- Changed:emem_intentChanges thingsinputSchema
- Changed:emem_locateOnly readsdescription
- Changed:emem_toolsChanges thingsdescription
Install
Pinned to version 2.4.6. Values in angle brackets are yours to fill in.
claude mcp add --transport http emem https://emem.dev/mcpclaude mcp add --transport http emem https://emem.dev/mcpRun in a terminal.
Claude Code permissions
Allow the reads, ask before a change or a way out, deny the deletes. Paste into .claude/settings.json.
{
"permissions": {
"allow": [
"mcp__emem__emem_locate",
"mcp__emem__emem_memory_token_resolve",
"mcp__emem__emem_memory_contradictions",
"mcp__emem__emem_entity_resolve"
],
"ask": [
"mcp__emem__emem_entity",
"mcp__emem__emem_recall",
"mcp__emem__emem_memory_token",
"mcp__emem__emem_verify_receipt",
"mcp__emem__emem_guard_verdict",
"mcp__emem__emem_tools",
"mcp__emem__emem_ask",
"mcp__emem__search",
"mcp__emem__fetch",
"mcp__emem__emem_echo_verify",
"mcp__emem__emem_memory_bundle",
"mcp__emem__emem_entity_link",
"mcp__emem__emem_find_similar",
"mcp__emem__emem_intent"
],
"deny": []
}
}Tools that only read are allowed, tools that change things ask first, tools that delete or cancel are denied. A read that can send data out (it takes a URL, say) asks first too. It assumes the server is installed as emem. Review it before you use it.
Capability tags behind 11 rules
- mcp__emem__emem_entity untrusted-input
- mcp__emem__emem_locate untrusted-input
- mcp__emem__emem_recall untrusted-input
- mcp__emem__emem_ask untrusted-input
- mcp__emem__search untrusted-input
- mcp__emem__fetch untrusted-input
- mcp__emem__emem_memory_bundle untrusted-input
- mcp__emem__emem_entity_resolve untrusted-input
- mcp__emem__emem_entity_link untrusted-input
- mcp__emem__emem_find_similar untrusted-input
- mcp__emem__emem_intent untrusted-input
Pin
Keep the decision: fail CI when the tools change, follow every change, or show a badge.
Pin in CI
Fail a build when the tools you reviewed are not the tools the server serves today.
curl -s "https://radar.anlyon.com/api/v1/servers/io.github.Vortx-AI/emem/verify?hash=ab8c5eb93119a2d32a043b027acfd53995680389a78c76f6479fdf94bcdfde1e" | jq -e '.changed == false'Pinned hash ab8c5eb93119, from Nov 20, 2026, 10:18 UTC.
Watch
Get told when its tools change: a new tool, a new description, a new class.
https://radar.anlyon.com/servers/io.github.Vortx-AI/emem/changes.xmlAn Atom feed. Works in any feed reader or Slack's RSS app.
Badge
[](https://radar.anlyon.com/servers/io.github.Vortx-AI/emem)Source: MCP Registry · repository. Synced Nov 20, 2026, 10:17 UTC.
emem, the verifiable memory protocol for the physical world MCP server: questions and answers
Answered from the scan above, not from the publisher's description.
Is the emem, the verifiable memory protocol for the physical world MCP server safe?
- No scan can promise that. What its definitions show: 18 tools, 14 of which can change, send or delete something, and 7 findings from fixed checks. Allow the reads, ask before each change, and deny the deletes; the permissions block on this page does that.
Can the emem, the verifiable memory protocol for the physical world MCP server delete data?
- No tool is classed as destructive: going by their definitions, none of them deletes, cancels or revokes anything.
Can the emem, the verifiable memory protocol for the physical world MCP server do things that cannot be undone?
- No tool is classed as irreversible: none of them sends, pays, publishes or merges, going by their definitions.
What tools does the emem, the verifiable memory protocol for the physical world MCP server have?
- 18 tools: 14 write, 4 read. emem_entity, emem_recall, emem_memory_token, emem_verify_receipt, emem_guard_verdict, emem_tools, emem_ask, search and 10 more.
Does the emem, the verifiable memory protocol for the physical world MCP server need sign-in or OAuth?
- Its remote endpoint listed its tools to an anonymous client, without sign-in.
Does the emem, the verifiable memory protocol for the physical world MCP server send data to outside services?
- None of its tools sends, posts or publishes, or takes a recipient, channel or URL.
Has the emem, the verifiable memory protocol for the physical world MCP server changed its tools?
- Yes, 3 times since Anlyon Radar started tracking it, most recently on Nov 20, 2026. Every change is on this page and in its Atom feed.