product · memory layer

engram

an open cross-modal memory for physical ai, built on the family and searchable in plain language.

family fusion embedding 2·base fe2 + sense packs·output 2048-d index·license product

engram is the memory layer, the product the models exist to power. it indexes a robot's video, audio, and motion into one embedding space on a shared clock, then answers plain-language questions about what happened.

it is not a single model. it is the system that turns the family's shared space into a queryable memory of a physical agent's experience, and it has been validated on real recordings, not only synthetic data.

how it works

every sense a robot records is embedded into the same fe2 space and stamped onto one shared clock. a plain-language question then retrieves across all of them at once: you can ask what it saw or how it moved and get real embedding matches back, ranked.

beyond retrieval, engram answers temporal and episodic questions that pure similarity cannot. deterministic operators (last, count, before, timeline) run over the indexed memory, and episode segmentation plus salience give the memory structure rather than a flat pile of moments.

engram pipeline: video, audio, and motion are embedded by fusion embedding 2 plus packs, indexed, then read by temporal operators to produce a plain-language answer. — architecture: frozen components in grey, the trained / new path in terracotta, all reading out into one shared 2048-d space.

training data

engram trains nothing new. it indexes fusion embedding 2 (plus sense packs) on a shared clock and reads the resulting space with deterministic operators.

it has been validated on real ego4d human egocentric recordings and on a real unitree humanoid, not only on synthetic data. the playground is a live slice of that memory: forty real moments from a humanoid's shift, with real fe2 embeddings, searched by cosine similarity in your browser.

results

the engram playground is the honest demonstration: forty real moments from a unitree humanoid's shift, every result a real embedding match ranked live in the browser. it retrieves across video and motion and answers temporal questions the underlying embeddings alone cannot.

honest limitations

—engram is only as strong as the senses underneath it; fine motion queries, for instance, inherit the current limits of the motion head.
—it is a memory and reasoning layer, not a planner or controller.

usage

from engram import Memory

# engram indexes Fusion Embedding 2 embeddings on one shared clock
mem = Memory(model="EximiusLabs/fusion-embedding-2-2b-preview")
mem.add(video="shift.mp4", audio="shift.wav", motion="imu.npy")

# retrieval reaches across every sense at once
hits = mem.search("pouring water into a cup")

# deterministic temporal operators over the indexed memory
last_pickup = mem.last("when did it pick something up")
timeline    = mem.timeline(episode=hits[0].episode)

citation

@software{eximius_engram_2026,
  author = {Eximius Labs},
  title  = {Engram: a cross-modal, temporally-aware memory layer
            for physical AI},
  year   = {2026},
  url    = {https://github.com/Eximius-Labs},
}

how it fits the family

engram is where the whole family comes together: fusion embedding 2 as the anchor space, the sense packs feeding it, and the deterministic operators reading it.

try it directly in the playground: a real robot's memory, searched live.

← all models playground