Skip to main content
Glama

emem, the verifiable memory protocol for the physical world

Recall facts at a cell (auto-materializes on miss)

emem_recall
Idempotent

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 paraphrase: resolving it anywhere returns those exact bytes. It is NOT a fingerprint of the observation. The digest covers the responder's key and the moment it signed, so two responders that measure the same thing mint different fact_cids and a cid resolves only at the responder that signed it; use emem_entity for identity that crosses responders. Pass deterministic:true (or a provenance class list) to keep only facts recomputable from the cited raw source, with no model or human in the loop. In the memory algebra this is ensure(cell, bands), not get: state what must exist and the responder reuses or materializes.

When to use: Call after emem_locate (or with a known cell64). Returns every Primary fact stored at that (cell, band, tslot). IMPORTANT: if the cell has no fact yet for a requested band AND that band has has_materializer=true (per emem_coverage_matrix / emem_materializers), the responder fetches the upstream value, signs it under its identity, persists it, and returns it in the same response (slower on the first call while the upstream is fetched; fast once cached). So for any wired band you can recall ANY cell on Earth without seeding, just pass bands: [<band>]. The response carries materialize_notes listing what was just fetched. Empty result with no notes means the band has no materializer at this responder.

Example arguments: {"cell":"damO.zb000.xUti.zde78","bands":["weather.temperature_2m","copdem30m.elevation_mean"]}

Input Schema

TableJSON Schema
NameRequiredDescriptionDefault
latNoExplicit latitude, an alternative to `cell`; paired with `lng`.
lngNoExplicit longitude, paired with `lat`.
bandNooptional single band key, convenience alias for bands:[band]. Use when you want exactly one band (e.g. 'geotessera.2020', 'modis.ndvi_mean') and would otherwise have to wrap it in an array. Both `band` and `bands` are accepted; if both are given they are merged.
cellYescell64 string, e.g. 'damO.zb000.xUti.zde78'
bandsNooptional band keys to filter, e.g. ['indices.ndvi','geotessera']
placeNoFree-text place name, an alternative to `cell`.
scopeNoOptional multi-tenant scope {user_id, agent_id, run_id, org_id}. When at least one field is set, the recall is FILTERED to facts written under the same four-tuple (a recall scoped to {user_id:'u1'} sees only u1's facts, never another tenant's and never globally-written facts) AND the signed receipt binds the scope. Omit (or send {}) for the global, pre-v0.0.8 recall.
tslotNooptional time slot (band-tempo-relative integer offset from emem epoch)
cell64NoAlias for `cell`.
includeNoOpt-in response expansion. include:['provenance'] attaches each fact's tamper-provenance class, which is what `deterministic` and the `provenance` filter select ON: without it you can filter by class and never be told which class a returned fact is. include:['freshness'] attaches an advisory per-fact freshness block: a Q(Δt) staleness score from the band's physics decay kernel (the same one /v1/temporal_route ranks bands with), so an agent learns how stale each reading is in the call that returns it. Advisory only; it does NOT enter the receipt. include:['edges'] attaches each fact's typed temporal edges and threads their CIDs into the receipt. Absent leaves the response byte-identical to the pre-v0.0.9 recall.
provenanceNoTamper-provenance filter: return only facts whose band's provenance class is in this list. `attested_execution` is a device reading trusted through its verified OS execution trace and platform attestation (not recomputable). Applied BEFORE the receipt is signed, so the receipt covers exactly the returned facts; `bands_already_attested_at_cell` stays unfiltered so you still see what else exists at the cell.
as_of_tslotNoBi-temporal valid-time bound. Returns the latest fact per (cell,band) whose tslot ≤ as_of_tslot, answers `what did this place look like AS OF date X`. Conflicts with an explicit `tslot` when as_of_tslot < tslot (rejected with code:`invalid_temporal_bound`).
deterministicNoSugar over `provenance`: true keeps only facts any third party can recompute from the cited raw source (direct_sensor + deterministic_index); false keeps the rest (attested_execution + model_output + human_curated + unclassified). Composable with `provenance` (intersection).
as_of_signed_atNoBi-temporal transaction-time bound. RFC 3339 string. Returns only facts whose `signed_at` ≤ as_of_signed_at, answers `what did emem KNOW as of system-date Y`. Malformed strings are rejected with code:`invalid_signed_at_format`.

Output Schema

TableJSON Schema
NameRequiredDescriptionDefault
factsYesSigned facts at the cell, ordered per fact_order.
receiptYesed25519 receipt over the returned fact_cids. Verify offline; select the rule from its preimage_version. Store and forward it byte-for-byte: preimage_version 2 binds every field it covers, including merkle_proof, so a reshaped receipt reports signature_valid:false on data nobody tampered with.
fact_orderYesThe ordering contract for facts, e.g. tslot_ascending. Stated rather than implied so nothing depends on position by accident.
current_by_bandNoPer band, the fact_cid with the highest tslot: the current reading. Unslotted facts are excluded, since tslot 0 means undated rather than oldest.
materialize_notesNo
bands_already_attested_at_cellNoWhat else is readable here without materialising, so an empty result can be told apart from a wrong band name.

TDQS

A4.8/5.0
Behavior5/5

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

The annotations only provide generic flags (readOnlyHint:false, openWorldHint:true, idempotentHint:true, destructiveHint:false), so the description carries the full behavioral burden. It discloses the write side-effect of auto-materialization, that a fact_cid is not a paraphrase or fingerprint, that a cid resolves only at the signing responder, and that the receipt binds provenance filters. No annotation is contradicted.

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

Conciseness4/5

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

The description is long, but the length is earned by a 14-parameter, 6-aspects tool: core read semantics, the non-fingerprint caveat, cross-responder cid behavior, materialization side effects, the ensure-not-get framing, and an example. It is front-loaded with the primary definition and contains no pure filler or repetition of schema content.

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?

For the tool's complexity, schema richness (100% coverage), and presence of an output schema, the description covers exactly the gaps that structured data cannot: when to call it, what side effect materialization produces, how to read the response to detect a missing materializer, and how filters interact with the receipt. Nothing an agent needs to invoke it safely is missing.

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

Parameters4/5

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

The schema already documents all 14 parameters with 100% coverage, which mandates a baseline of 3. The description adds genuine value on top: it explains deterministic as sugar over the provenance filter, warns that without include:['provenance'] an agent can filter by class yet never be told the returned class, and supplies a concrete example with a realistic cell64 and band list.

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 opening sentence names a specific verb and resource: 'Read the signed facts at a canonical address (cell64)' and immediately adds the distinguishing auto-materialization-on-miss behavior. It further separates itself from emem_entity ('use emem_entity for identity that crosses responders') and frames itself as ensure(cell, bands), not get, so an agent can distinguish it from siblings without inspecting schemas.

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?

An explicit 'When to use' paragraph says to call after emem_locate or with a known cell64, which anchors the tool in an invocation sequence. It also gives an exclusion and an alternative ('use emem_entity for identity that crosses responders') and tells the agent the materialzation behavior to expect (slow first call, fast once cached, empty result with no notes means no materializer).

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

Try in Browser

Glama MCP Gateway

Add one secure layer between your agents and this server.

TDQS

A4.3/5.0
Disambiguation4/5

Most tools are sharply distinct, with the entity_* family (mint/resolve/link) and memory_* family (token/bundle/contradictions) explicitly cross-referenced to prevent confusion. The only mild overlap is the verify cluster — emem_echo_verify, emem_verify_receipt, and emem_guard_verdict all touch verification but are well-delineated (value drift vs. cryptographic envelope vs. policy gate) — and emem_intent's type:'ask' row duplicating emem_ask.

Naming Consistency4/5

All tools share the emem_ prefix and snake_case, with systematic sub-families (emem_entity*, emem_memory_token*, emem_verify*) that make relationships predictable. However, the pattern is not uniformly verb_noun: bare nouns (emem_entity, emem_intent, emem_tools, emem_recall) and mixed constructions like emem_echo_verify and emem_find_similar deviate from a single convention.

Tool Count4/5

16 tools is just over the ideal 3-15 range, but the count is deliberate: the server curates a small core loop and provides emem_tools as a discovery meta-tool to reach the broader 108-tool catalog. Each listed tool earns its place in the locate → recall → cite → resolve → verify workflow, so the slight overage feels justified rather than bloated.

Completeness4/5

The full consumption lifecycle is covered: locate (emem_locate), recall (emem_recall), ask (emem_ask), cite (emem_memory_token/bundle), resolve (emem_memory_token_resolve), verify (emem_verify_receipt/echo_verify), with entity identity, contradiction detection, similarity search, and policy guard as extras. Minor gaps exist — emem_diff for pair quantification and emem_recall_polygon for regions are referenced but not in the core list, and there is no write/attest tool (though that appears to be by design for a verifiable memory protocol).