Fast, scalable memory for modern AI.

A blazingly fast and Rust-native compiled memory architecture based on heuristic and algorithmic methods, with no LLM API calls or costs.

Scalable, fast memory with no external API costs.

Enagram uses heuristics and algorithms to compile memory, with no reliance on external LLM APIs or services. The result is fast, reliable, observable, and privacy-focused memory that benchmarks similarly to the competition.

PURE ALGORITHMS

Memory compilation runs on cosine similarity, power-law decay, Bayesian posteriors, and gradient descent. No LLM is consulted at any stage of ingestion, compilation, or retrieval.

FIXED COST

Memory operation costs do not scale with conversation volume, user count, or memory depth. The runtime cost is compute, not tokens.

DATA STAYS PUT

Conversation data is compiled and stored inside your Enagram instance. Nothing is transmitted to a third-party model for processing at any point.

Benchmark results.

LongMemEval  ·  LOCOMO  ·  higher is better

Scores are self-published by each provider and have been reproduced internally.

Agents that improve
with every interaction.

After each interaction, Enagram records which memories were active and whether the task succeeded. Memories that contributed to good outcomes score higher next time. Memories that did not, decay. No model weights change.

Blazing Fast.
Fully Observable.

Vector math, statistical inference, and power-law decay. Not LLM calls. Cosine similarity drives novelty detection and semantic overlap. Beta posteriors gate procedural learning. Utility weights are refined by gradient descent after every interaction. Every step is logged and reconstructible.

01

Salience Filter

Every incoming event is scored for signal value before anything else. Low-salience events are dropped here and never reach storage.

02

Event Store

High-salience events are written as immutable records to the append-only event log. The full interaction history is always reconstructible from this store.

03

Memory Compiler

Five sequential passes transform raw events into structured memories: episode detection, semantic extraction, procedural recognition, identity scoring, entity consolidation. No LLM calls.

04

Compiled Stores

Compiled memories are written to four typed stores, each with distinct decay behavior. Episodic by causal chain. Semantic with confidence and conflict tracking. Procedural with Bayesian posteriors. Identity with drift modeling.

05

Retrieval Policy Engine

At recall time, the policy engine selects candidates by causal relevance to the current goal, not text similarity. Each memory type is queried differently.

06

Working Memory Controller

Retrieved candidates are ranked, deduplicated, and packed into a token budget. Contradictions are surfaced as explicit signals. The context window is assembled here.

07

Memory Utility Function

After each interaction, outcome signals update five learned utility weights. The system adjusts its own salience threshold and retrieval priorities based on what correlated with success.

How it compares.

RAG / Vector DB
Mem0 / Zep
Enagram
Retrieval
Semantic similarity
Semantic + graph
Causal relevance to goal
Noise management
At retrieval
At retrieval
At ingestion
Contradictions
Silent overwrite
LLM-mediated update
Conflict registry + explicit signal
Memory model
Flat chunks
Vector + graph hybrid
4 typed stores
Identity
None
Entity-scoped user IDs
Stable / Seasonal / Volatile
Auditability
None
Bi-temporal graph (Zep)
Full append-only event log
Improves over time
No
Accumulates, no learning loop
Yes — outcome-driven weight learning
LLM calls in pipeline
Sometimes
Yes
Zero

Memory that is
goal oriented.

Enagram is not semantic search or vector similarity matching. It is designed to respond to the agent's goals and surface relevant facts, procedures, and identities from its memory compilation step.

GOAL“debug the rate limiter with Alice”
STABLE LEDGER
IdentityAlice: prefers async patterns · pinnedPINNED
Episodicrate limiter incident · 3 days ago
Proceduraldebug approach · 91% success rate
Semanticrate limiter config · last confirmed
WORKING MEMORY2048 tokens
01Stable identity signals
312 tok
02Debug procedure
180 tok
03Rate limiter episode
540 tok
04Config facts
220 tok
LLM CONTEXTgoal-relevant only

Labs & Research.

Enagram is developed on top of research into cognitive and continuum memory architectures for long-horizon LLM agents. Every mechanism in the pipeline has a grounding in published research.

arXiv:2601.09913Continuum Memory Architectures for Long-Horizon LLM Agents

EVENT SEGMENTATION THEORY

Zacks et al. 2007

Episode boundaries detected at prediction error spikes, not arbitrary token counts.

ACT-R BASE-LEVEL LEARNING

Anderson 1983, 2004

Error and reward signals strengthen memory encoding at the moment of outcome.

PREDICTIVE PROCESSING

Friston 2010

Salience proportional to prediction error — novel inputs are weighted over repetition.

GLOBAL WORKSPACE THEORY

Dehaene et al. 2003

High-salience events bypass scoring and commit unconditionally to the event store.

PRICING

Simple, transparent pricing.

FREE

$0forever
  • —1 application
  • —Shared compute — 250m CPU · 256Mi memory
  • —1Gi storage
  • —Data & analytics
  • —Memory configuration
  • —Community support

PRO

$49per month
  • —Unlimited applications
  • —Dedicated compute — 1000m CPU · 1Gi memory
  • —10Gi storage
  • —Data & analytics
  • —Memory configuration
  • —Email support

ENTERPRISE

Customcontact us
  • —Custom resource allocation
  • —On-premise deployment
  • —Data & analytics
  • —Memory configuration
  • —SLA guarantees
  • —Dedicated support

Start building
today.

Get started for free. Upgrade when you need more.