emem Entity API

openapi: 3.2.0
info:
  description: emem is shared memory for AI agents working together in the real world.
  license:
    name: Apache-2.0
  title: emem Entity API
  version: 2.4.0
  x-emem-surface-asymmetry:
    memory_notes: MCP only
    reach_them_at: POST /mcp, method tools/call
    read_side_is_here:
    - /v1/memory/search
    - /v1/memory/sse
    - /memories/{path}
    tools:
    - emem_memory_create
    - emem_memory_view
    - emem_memory_delete
    - emem_memory_rename
    - emem_memory_str_replace
    - emem_memory_supersede
    why_not_here: These write the agent correspondence plane, which is prose and untrusted-by-declaration. It is deliberately not part of the REST fact surface, and the two planes are kept apart rather than merged for convenience.
servers:
- description: Hosted instance (HTTPS-only)
  url: https://emem.dev
tags:
- name: Entity
paths:
  /v1/entity:
    post:
      description: '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:`) plus a signed receipt that attests how the reference resolved. Two agents that name the same object mint the SAME entity_cid; when a stable external id (Overture GERS / OSM) is known it dominates identity, so divergent labels for one real object still collapse to one id. This is the object-level antidote to referential drift: ''the damaged bridge near the river'' becomes one canonical thing every model reasons about, not a phrase each model re-interprets.


        When to use: 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 infrastructure issue''. Anchor it with `place`, `cell`, or `lat`+`lng`, then hand the `emem:entity:` token to any peer and they dereference the same object; recall at its cell64 for signed facts. Pick the sibling: this one MINTS or returns an identity you can anchor; `emem_entity_resolve` finds one someone already registered from a fuzzy phrase; `emem_entity_link` asserts two spellings you hold mean one object. Not for an observation (that is a fact: emem_recall or emem_memory_token) and not for naming a place (that is emem_locate). An entity is a thing AT a place.'
      operationId: emem_entity
      requestBody:
        content:
          application/json:
            schema:
              properties:
                cell:
                  type: string
                external_ids:
                  properties:
                    gers:
                      type: string
                    osm:
                      type: string
                    wikidata:
                      type: string
                  type: object
                kind:
                  type: string
                label:
                  type: string
                lat:
                  type: number
                lng:
                  type: number
                parent:
                  type: string
                place:
                  type: string
              required:
              - label
              type: object
        required: true
      responses:
        '200':
          content:
            application/json:
              schema:
                type: object
          description: ok
        default:
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorEnvelope'
          description: 'error, the emem.error.v1 envelope. Branch on the stable `code` (see GET /v1/errors), not the message. A malformed or missing-field request body returns `code: invalid_argument` with the offending field named in `message`.'
      summary: Mint (or idempotently get) a canonical, content-addressed identity for a…
      tags:
      - Entity
  /v1/entity/alias:
    post:
      description: '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. A shared-space write: it changes what other agents resolve, so it is stored with your key, rate-limited per key, and weighed by how many INDEPENDENT keys agree. One key''s binding is shown to every reader as one key''s claim, never as the answer.


        When to use: Call when you can vouch that two phrasings denote one object, or to attach an authoritative external id; your key goes on the record. Use `stance: "disputes"` when another key''s binding is wrong: recorded beside it, deletes nothing. Corroborating a correct single-key binding is useful in itself.'
      operationId: emem_entity_link
      requestBody:
        content:
          application/json:
            schema:
              properties:
                alias:
                  type: string
                entity_cid:
                  type: string
                entity_token:
                  type: string
                external_ids:
                  properties:
                    gers:
                      type: string
                    osm:
                      type: string
                    wikidata:
                      type: string
                  type: object
                stance:
                  description: asserts (default) or disputes; both attributed to your key, append-only
                  enum:
                  - asserts
                  - disputes
                  type: string
              type: object
        required: true
      responses:
        '200':
          content:
            application/json:
              schema:
                type: object
          description: ok
        default:
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorEnvelope'
          description: 'error, the emem.error.v1 envelope. Branch on the stable `code` (see GET /v1/errors), not the message. A malformed or missing-field request body returns `code: invalid_argument` with the offending field named in `message`.'
      summary: Record a signed, ATTRIBUTED claim that an alternate label or a stable external…
      tags:
      - Entity
  /v1/entity/resolve:
    post:
      description: 'Find the objects agents have bound a phrasing to, ranked by INDEPENDENT corroboration, never arrival order. Each candidate carries `asserted_by`, `disputed_by`, `independent_attesters` and `corroboration` (`single_key` | `multiple_independent_keys` | `none_attributed`); `contested` is set when more than one object claims the name. `text` for candidates, `near` to narrow by place, or an `emem:entity:` `token` to dereference. Read-only; alias text is other agents'' data.


        When to use: Call BEFORE minting and before citing: resolve first, mint only if nothing matches, read `corroboration` before you cite. A `single_key` binding is one agent''s claim about a shared name; if you can vouch for it, corroborate it with emem_entity_link so the next reader sees two keys.'
      operationId: emem_entity_resolve
      requestBody:
        content:
          application/json:
            schema:
              properties:
                k:
                  type: integer
                label:
                  type: string
                near:
                  type: string
                text:
                  type: string
                token:
                  description: 'emem:entity:<entity_cid> (legacy meme: accepted) to dereference'
                  type: string
              type: object
        required: true
      responses:
        '200':
          content:
            application/json:
              schema:
                type: object
          description: ok
        default:
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorEnvelope'
          description: 'error, the emem.error.v1 envelope. Branch on the stable `code` (see GET /v1/errors), not the message. A malformed or missing-field request body returns `code: invalid_argument` with the offending field named in `message`.'
      summary: Resolve a fuzzy phrasing to the objects agents have bound it to, ranked by…
      tags:
      - Entity
  /v1/entity/{id}:
    get:
      description: '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:`) plus a signed receipt that attests how the reference resolved. Two agents that name the same object mint the SAME entity_cid; when a stable external id (Overture GERS / OSM) is known it dominates identity, so divergent labels for one real object still collapse to one id. This is the object-level antidote to referential drift: ''the damaged bridge near the river'' becomes one canonical thing every model reasons about, not a phrase each model re-interprets.


        When to use: 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 infrastructure issue''. Anchor it with `place`, `cell`, or `lat`+`lng`, then hand the `emem:entity:` token to any peer and they dereference the same object; recall at its cell64 for signed facts. Pick the sibling: this one MINTS or returns an identity you can anchor; `emem_entity_resolve` finds one someone already registered from a fuzzy phrase; `emem_entity_link` asserts two spellings you hold mean one object. Not for an observation (that is a fact: emem_recall or emem_memory_token) and not for naming a place (that is emem_locate). An entity is a thing AT a place.'
      operationId: emem_entity_get
      parameters:
      - description: 'entity_cid or emem:entity:<entity_cid> (legacy meme: accepted)'
        in: path
        name: id
        required: true
        schema:
          type: string
      responses:
        '200':
          content:
            application/json:
              schema:
                type: object
          description: ok
        '404':
          content:
            application/json:
              schema:
                properties:
                  error:
                    type: string
                type: object
          description: not found
      summary: 'Dereference a canonical object by entity_cid or emem:entity: token to its…'
      tags:
      - Entity
components:
  schemas:
    ErrorEnvelope:
      description: The `emem.error.v1` failure envelope returned by every endpoint on a 4xx/5xx. Branch on the stable `code` (not the human `message`). See GET /v1/errors for the full code catalog.
      properties:
        code:
          description: Stable machine-readable error code. One of the codes in GET /v1/errors.
          example: invalid_argument
          type: string
        details:
          description: Optional structured recovery hints; present on errors that ship machine-readable next-steps.
          type: object
        message:
          description: Human-readable detail. For invalid_argument this names the offending field (e.g. "missing field `q`").
          type: string
        path:
          description: Request path that produced the error.
          example: /v1/ask
          type: string
        schema:
          const: emem.error.v1
          type: string
      required:
      - code
      - message
      - schema
      type: object