emem, the verifiable memory protocol for the physical world

Check a value against the fact it cites, before you publish it

emem_echo_verify

Read-onlyIdempotent

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 error into a caught event instead of a silent wrong number: a model that resolves a fact correctly can still retype 0.2411 for 0.241103, and nothing else in the loop notices. Memory algebra: the verify operation (https://emem.dev/docs/model.html).

When to use: Call immediately before publishing, logging, or handing on any value you took from an emem fact, and treat a false matches as a gate rather than a warning. Pair it with value_verbatim from resolve: quote that exact decimal string rather than reformatting the number, then echo-verify what you actually emitted. For a due-diligence or compliance record this is what lets you assert every cited value was echo-verified with a signed check per citation instead of a promise. Accepts a bare cid too, so a damaged citation still grades rather than failing closed.

Example arguments: {"token":"emem:fact:defi.zb572.xoso.zb1ec:4qj3l4mgh7ch5kvxmkqspjdl6y42oqhm42khh3gostccpixkbz5q","claimed_value":"-0.0522"}

Input Schema

TableJSON Schema

Name	Required	Description
`token`	Yes	The citation you used. Any form resolve accepts, including a bare cid, which answers with `degraded: true`: a bare cid asserts no location, so the cell-binding check is skipped and the grade covers the value only. A cid that is not 52 characters is refused as a damaged citation rather than as a missing one, and must not be retried.
`strict`	No	Require BYTE-IDENTICAL equality. Default false, which also accepts a numerically equal value spelled differently (0.50 for 0.5). It changes exactly one outcome: the numerically-equal-but-respelled case, which passes by default and becomes `drift: "reformatted"` here. `rounded` and `wrong` already fail either way, so `strict` never turns a pass into a pass. It is also inert when `claimed_value` came in as a JSON number, because the respelling then happened in the JSON parser, before this tool saw it.
`claimed_value`	Yes	The value you are about to publish, as a string or a number. Send it as a STRING, character for character as you will emit it. A JSON number is stringified before the comparison, so `0.50` arrives as `0.5` and `0.2411000` as `0.2411` (measured against the live responder): the trailing digits this check exists to defend are gone before it runs. Quote `value_verbatim` from resolve as a string and echo the exact characters you will publish.

Output Schema

TableJSON Schema

Name	Required	Description
`drift`	No	The difference between what you wrote and what emem holds, when they disagree. Explicit null on an exact match: the key is always present, so branch on its value rather than on whether it exists. Declaring this `string` alone was a live schema violation on every matching call, which is how it was found.
`token`	Yes	The citation you passed, echoed back exactly as sent.
`matches`	Yes	Whether what you were about to publish agrees with the signed fact. Treat false as a gate, not a warning.
`receipt`	No
`degraded`	No	True when a bare cid was passed and the cell binding could not be checked.
`fact_cid`	No
`claimed_value`	Yes	Echoed back, so a log line carries both sides of the comparison.
`canonical_token`	No	The token in its canonical spelling, whatever form you passed.
`offline_verify_at`	No	Where to re-run this check without trusting this responder.
`resolved_value_verbatim`	No	The fact's value as the exact decimal string it was signed as. Quote this rather than reformatting it.

Schema Changelog

Changes observed during successful MCP inspections.

Changed1 schema field changedSep 14, 2026
- addedInput schema / properties / claimed_value / type
```
Added value: +[
+  "string",
+  "number"
+]
```

Changed4 schema fields changedAug 12, 2026

changedInput schema / properties / claimed_value / description

Previous value: -"The value you are about to publish, as a string or a number. A string is compared verbatim first, which is what catches a retype a float comparison would forgive."New value: +"The value you are about to publish, as a string or a number. Send it as a STRING, character for character as you will emit it. A JSON number is stringified before the comparison, so `0.50` arrives as `0.5` and `0.2411000` as `0.2411` (measured against the live responder): the trailing digits this check exists to defend are gone before it runs. Quote `value_verbatim` from resolve as a string and echo the exact characters you will publish."

changedInput schema / properties / strict / description

Previous value: -"Require BYTE-IDENTICAL equality. Default false, which also accepts a numerically equal value spelled differently (0.50 for 0.5)."New value: +"Require BYTE-IDENTICAL equality. Default false, which also accepts a numerically equal value spelled differently (0.50 for 0.5). It changes exactly one outcome: the numerically-equal-but-respelled case, which passes by default and becomes `drift: \"reformatted\"` here. `rounded` and `wrong` already fail either way, so `strict` never turns a pass into a pass. It is also inert when `claimed_value` came in as a JSON number, because the respelling then happened in the JSON parser, before this tool saw it."

changedInput schema / properties / token / description

Previous value: -"The citation you used. Any form resolve accepts, including a bare cid (answers degraded)."New value: +"The citation you used. Any form resolve accepts, including a bare cid, which answers with `degraded: true`: a bare cid asserts no location, so the cell-binding check is skipped and the grade covers the value only. A cid that is not 52 characters is refused as a damaged citation rather than as a missing one, and must not be retried."

changedOutput schema / (root)

Previous value: -nullNew value: +{
+  "properties": {
+    "canonical_token": {
+      "description": "The token in its canonical spelling, whatever form you passed.",
+      "type": "string"
+    },
+    "claimed_value": {
+      "description": "Echoed back, so a log line carries both sides of the comparison.",
+      "type": "string"
+    },
+    "degraded": {
+      "description": "True when a bare cid was passed and the cell binding could not be checked.",
+      "type": "boolean"
+    },
+    "drift": {
+      "description": "The difference between what you wrote and what emem holds, when they disagree. Explicit null on an exact match: the key is always present, so branch on its value rather than on whether it exists. Declaring this `string` alone was a live schema violation on every matching call, which is how it was found.",
+      "type": [
+        "string",
+        "null"
+      ]
+    },
+    "fact_cid": {
+      "type": "string"
+    },
+    "matches": {
+      "description": "Whether what you were about to publish agrees with the signed fact. Treat false as a gate, not a warning.",
+      "type": "boolean"
+    },
+    "offline_verify_at": {
+      "description": "Where to re-run this check without trusting this responder.",
+      "type": "string"
+    },
+    "receipt": {
+      "type": "object"
+    },
+    "resolved_value_verbatim": {
+      "description": "The fact's value as the exact decimal string it was signed as. Quote this rather than reformatting it.",
+      "type": "string"
+    },
+    "token": {
+      "description": "The citation you passed, echoed back exactly as sent.",
+      "type": "string"
+    }
+  },
+  "required": [
+    "matches",
+    "token",
+    "claimed_value"
+  ],
+  "type": "object"
+}

AddedJul 20, 2026

TDQS

A5/5.0

Behavior5/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Beyond annotations, the description discloses nuanced behaviors: `strict` changes exactly one outcome, JSON numbers lose trailing digits before comparison, and a non-52-character cid is refused as damaged. These are load-bearing edge cases an agent needs to know before calling.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is long but every sentence carries operational weight: the primary purpose, the verification workflow, the strict-mode caveats, and a concrete example. It is well-structured with a 'When to use' section and front-loaded core behavior.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

With an output schema present and annotations covering the read-only, idempotent safety profile, the description still fills all practical gaps: return semantics, failure modes, parameter formatting, and pairing guidance. Nothing needed for confident invocation or selection is missing.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters5/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 100%, yet the description adds substantial value beyond it: it explains why `claimed_value` should be sent as a string, how `strict` interacts with numeric respelling, and how bare cids alter the grade. This goes well above the schema's own parameter descriptions.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description states a specific verb and resource: 'Grade a value you are about to emit against the signed fact your citation points at,' and says it returns `matches` and `drift`. It clearly distinguishes this echo-verification step from related tools by naming the verify operation and pairing it with `value_verbatim` from resolve.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines5/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description gives explicit timing and conditions: 'Call immediately before publishing, logging, or handing on any value you took from an emem fact,' and instructs treating a false `matches` as a gate. It also names the companion tool, `value_verbatim`, and explains when a bare cid is appropriate.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

All emem, the verifiable memory protocol for the physical world tools Inspect

Try in Browser

One endpoint for every MCP toolRayrun runs every MCP server behind one URL and holds the credentials. Each call is decided per client, tool, and argument, then recorded.ray.runAd

Glama MCP Gateway

Add one secure layer between your agents and this server.