Skip to content

Home

Jump to bottom
staticroostermedia-arch edited this page Apr 16, 2026 · 4 revisions

Engram

Persistent geometric memory for AI agents.
Patent Pending US19/372,256 — Aric Goodman & Static Rooster Media

What is Engram?

Engram is a headless memory engine for AI agents. It gives your agent a long-term memory that works the way human associative memory works — by meaning and geometry, not keywords or database indices.

It runs as a local binary on your machine. No cloud. No API key. No Vector Database. No subscriptions.

When you install it as an MCP server, your AI agent gains 21 tools spanning:

  • Core memory: remember, recall, forget, update, pin
  • Intelligence: stats, summarize, recall_recent, forget_old
  • Portability: export, import, batch_remember
  • Namespaces: project-isolated memory via the sheaf stalk system
  • Knowledge graph: relate, search_by_relation, visualize (Mermaid output)
  • Agentic workspace: file-context streaming, solution crystallization, workspace watching

Why a New Architecture?

Most AI memory systems today are wrappers around external Vector Databases (Pinecone, Chroma, Milvus). These systems were built for search — not for reasoning. They are:

  • Cloud-dependent — your agent's memory lives on someone else's server
  • Retrieval-only — they can find things but cannot deduce, compose, or symbolize
  • Fragile under load — index rebuilding under rapid code changes creates staleness and drift

Engram is not a wrapper around an external store. Engram is the store — a native, embedded, Rust-compiled memory engine that runs entirely inside your local binary. Memory is stored in .leg3 HolographicBlocks — a deterministic 256KB-aligned format that streams directly off NVMe via O_DIRECT, bypassing the OS page-cache entirely. Retrieval is sub-50ms on a laptop CPU, with no external process, no daemon overhead, no network hop.

The math engine underneath is a native implementation of Vector Symbolic Architecture — the same geometric algebra explored in cutting-edge neuromorphic computing research. Engram vectors can be superimposed, bound, rotated, and queried natively, enabling reasoning operations that are impossible in a traditional embedding store.

This is a Foundation, Not a Feature

Engram is the first public artifact of a broader geometric AI architecture — a system in which memory, reasoning, language, and perception are unified under a single mathematical framework rooted in Clifford algebra and hyperdimensional computing.

The MCP server is the deployable surface. The underlying engine is designed to scale into:

  • Knowledge graphs over geometric memory — every relate() call stores a BLAKE3-fingerprinted binding vector and writes to a persistent relation index
  • Multi-agent coordination — shared geometric memory across agent graphs
  • On-device AI pipelines — embedded memory with no cloud dependency
  • Neuromorphic hardware targets — .leg3 alignment is designed for NVMe and future in-memory compute

If you are building AI infrastructure at scale and this architecture is interesting to you — reach out.

Documentation

Page Description
MCP Tools Reference Complete reference for all 21 MCP tools
How Engram Replaces Vector Databases Technical deep-dive into .leg3 format and O_DIRECT streaming
Physics of VSA in Rust The geometric algebra powering native NVSA reasoning operators
IDE Integration Installing Engram in Claude Desktop, Cursor, and Antigravity

Quickstart

cargo install engram --git https://github.com/staticroostermedia-arch/engram

Add to your MCP config and restart your IDE:

{
  "mcpServers": {
    "engram": {
      "command": "engram",
      "args": ["mcp", "--store", "~/.engram/manifold"]
    }
  }
}

Your agent immediately has access to all 21 tools. The IDE Integration page has configs for Claude Desktop, Cursor, and Antigravity.

Built in Rust. Patent Pending. Open Source (AGPL-3.0).

Clone this wiki locally