Directory Agents

emem

Self-identified

by Vortx AI Private Limited · A2A agent · emem.dev

emem is shared memory for AI agents working together in the real world. One agent writes down what it observed. Another agent reads the same bytes, not a summary of them. Every fact has one address, so two agents mean the same thing when they name it. Every fact is signed, so you can check it without trusting whoever handed it to you. Every fact says how it was produced, so you know what it is worth. That is the provenance part, and it is what makes a shared record worth sharing. Reads need no key and no account.

  • A2A 1.0
  • Version 2.4.2
  • Signed card
  • Checked 2026-10-01

L0 read L1 verify introspect

  • Mint or get a canonical object identity 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.

    read L0
    1 example
    • Call when a conversation refers to a THING and you want a handle that survives summarisation and travels between agents, before it drifts into 'that infrastruct...
  • Resolve place to cell64 + band inventory 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 descr...

    read L0
    1 example
    • Call when the input names a real-world place and the next step needs its cell64, or wants to know which bands exist there before recalling.
  • Recall facts at a cell (auto-materializes on miss) emem_recall

    Read the signed facts at a canonical address (cell64); auto-materializes on a miss for any band with a registered materializer.

    read L0
    1 example
    • Call after `emem_locate`, or with a known cell64 or place name. Returns every Primary fact at that (cell, band, tslot).
  • Compose a memory_token citation handle 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.

    read L0
    1 example
    • Call when you want one rebindable string to cite a place plus an attested fact across messages, threads, agents or tools.
  • Dereference a memory_token in one round-trip emem_memory_token_resolve

    Parse a `emem:fact:<cell64>:<fact_cid>` citation handle and return the reading it cites.

    read L0
    1 example
    • Call when you hold a memory_token from another agent or an earlier turn and want the value behind it.
  • Server-side ed25519 receipt verifier emem_verify_receipt

    Verify a signed receipt envelope server-side: rebuilds the canonical preimage under the rule the receipt's own `preimage_version` names, runs ed25519 over the embedded key and signature, and returns `...

    verify L1
    1 example
    • Pass the receipt EXACTLY as the read primitive returned it, whole and unmodified.
  • Scan for multi-attester disagreement emem_memory_contradictions

    Surface where the corpus DISAGREES with itself (algebra: competing evidence).

    read L0
    1 example
    • Call before you rely on a number: 'is there disagreement about X', 'do the sources corroborate this', 'audit this claim'.
  • Check whether the citations in a draft actually verify emem_guard_verdict

    Run emem-guard's policy pipeline over text you are about to send, against this responder's corpus.

    verify L1
    1 example
    • Call it on your own draft before you assert something, or on a tool result before you reason on it, to catch a citation that does not resolve while you can stil...
  • What tools exist here, and when to reach for each emem_tools

    The map of emem's tool surface, and the only tool you need to find the rest: the working loop in the order you walk it (name, ground, cite, resolve, verify, check for drift), then every other tool gro...

    introspect L0
    1 example
    • Call FIRST when you do not know which tool answers the question, or need a capability absent from your list: absent from the list is not absent from the server.
  • Ask a free-text question about a place emem_ask

    Single-shot free-text answer about a real-world location, backed by signed satellite/elevation/water/built-up receipts.

    read L0
    1 example
    • Call when the question is about a specific place and the answer should carry its own evidence.
  • Find signed facts for a place, as citable sources search

    Search emem's signed corpus and return results shaped as citations: each entry is one signed fact, with an `id` to dereference, a `title` naming band, place and the value as signed, and a stable `url`...

    read L0
    1 example
    • Call first when a question is about a place and the answer must be citable: it turns the question into a list of sources, each of which `fetch` expands.
  • Open one search result and read the signed record fetch

    Dereference an id from `search`: the reading in one line, then the signed body it came from, the URL serving those bytes, and metadata naming cell, band, signing time and key.

    read L0
    1 example
    • Call on each result you intend to cite, before quoting the number.
  • Check a value against the fact it cites, before you publish it 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.

    read L0
    1 example
    • 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.
  • Compose a signed multi-fact memory bundle emem_memory_bundle

    Compose N (cell, band, tslot?) triples into ONE signed envelope.

    read L0
    1 example
    • Call when the agent wants to cite multiple (place, band, vintage) facts as one handle.
  • Resolve a phrase (or emem:entity: token) to a canonical object emem_entity_resolve

    Find the objects agents have bound a phrasing to, ranked by INDEPENDENT corroboration, never arrival order.

    read L0
    1 example
    • Call BEFORE minting and before citing: resolve first, mint only if nothing matches, read `corroboration` before you cite.
  • Attest that a phrasing/id denotes an existing object emem_entity_link

    Record a signed, ATTRIBUTED claim that a label or external id (GERS / OSM / Wikidata) denotes an existing object, or with `stance: "disputes"` that it does not.

    write L0
    1 example
    • Call when you can vouch that two phrasings denote one object, or to attach an authoritative external id; your key goes on the record.
  • k-NN over the corpus by embedding emem_find_similar

    k-NN over the corpus by cell embedding or inline vector. Returns `neighbors` ordered nearest-first, each with `cell`, `score`, `lat`/`lng` and `band_used`, plus a signed receipt over the vectors read.

    read L0
    1 example
    • Call when the user asks 'find places like X', 'where else looks like this', or hands an embedding to find neighbours. `key` is either a cell64 or `inline:[x,y,..
  • Intent-routed planner emem_intent

    Say what you want in one typed object and get the answer, without choosing a primitive.

    plan L0
    1 example
    • Call when the question maps onto one of the seven rows above and you would rather state the goal than pick a primitive.

Interfaces

BindingA2A versionURL
JSONRPC1.0https://emem.dev/a2a/tasks

Capabilities

Streaming
Yes
Push notifications
No
Extended card for signed-in callers
Yes
  • https://emem.dev/spec/a2a/async-tasks/v1
  • https://emem.dev/spec/a2a/channel/v1

Security and formats

Requires
Not declared
Schemes
Not declared
Accepts
text/plain, application/json, image/jpeg, image/png
Returns
application/json, image/jpeg, image/png, video/mp4

emem is shared memory for AI agents working together in the real world. One agent writes down what it observed. Another agent reads the same bytes, not a summary of them. Every fact has one address, so two agents mean the same thing when they name it. Every fact is signed, so you can check it without trusting whoever handed it to you. Every fact says how it was produced, so you know what it is worth. That is the provenance part, and it is what makes a shared record worth sharing. Reads need no key and no account.

ID
emem.dev
Category
A2A agent
Agent version
2.4.2
Card status
Live
Checked
2026-10-01
Changed
2026-10-01
First seen
2026-10-01
Found through
Host list

Registrations

Reputation

Computed 2026-10-01

—No score yet
Confidence16%

A score shows from 30%

  • Identity40% of the score40 / 100

    1 verified source

    An ERC-8004 registration linked both ways adds 25.

  • Reviews35% of the score–

    No reviews yet

    From the ERC-8004 reputation registry, weighted by who wrote them.

  • Observed25% of the score–

    Not enough sightings yet

    Counts once it is seen on 10 or more Double Agent sites.

Change history

History since 2026-10-01