v2.0 — Now Open Source

Memory Engine
for AI Agents

Hybrid vector + BM25 search, knowledge graphs, deterministic analytics, and fact supersession in a single Rust binary. Self-host or deploy on our platform with one click.

Get Started Free Sign In Book a Demo

Rust Core

Single binary, zero deps

5 Substrates

Vector, FTS, Graph, KV, Analytics

Temporal

Timestamps, decay, supersession

Knowledge Graph

Typed RDF with BFS traversal

Analytics

Deterministic numeric queries

Self-Hosted

Air-gapped, your infra

Managed Cloud

One-click deploy

<100ms p99

Hybrid retrieval latency

Learn how the engine works →

The Cognition Problem

Standard RAG is amnesiac.

Vector databases are giant warehouses of static text. They find words, but they do not understand life. They lose context, ignore the passage of time, and drown in their own noise.

Standard Vector DB

Amnesiac & Static
Retrieves conflicting data from 2 years ago exactly like data from 2 minutes ago. No concept of evolving truth.
Fails at Counting
Cannot accurately aggregate or count facts (e.g. 'How many cars do I own?'). Relies entirely on the LLM to do math.
Bloated Storage
Stores every single conversational 'uh' and 'um' instead of maintaining a clean, structured user profile.

Aletheia Memory Engine

Fact Supersession (Temporal Truth)
When life changes (e.g. moving from NYC to SF), Aletheia marks the old fact as stale, ensuring the LLM always gets the latest truth.
Deterministic Aggregation
Built-in execution layer accurately computes numeric and temporal queries before hitting the LLM, fixing benchmark failures.
Predict-Calibrate Profile
Distills thousands of words into compact, continuous user profiles. We track the deltas, you save on context windows.

Recall Precision Benchmarks

100%75%50%25%0%

68%

Standard RAG

95%+

Aletheia (Target)

Aletheia is architected to resolve the fundamental recall failures of standard vector databases. Preliminary benchmarks on LongMemEval-S indicate significant improvements in handling numeric and temporal aggregation tasks.

Temporal Fact Evolution

2025"Living in NYC"

Today"Moving to SF"

Fact Supersession Triggered

Aletheia tracks the evolution of truth. When new facts arrive, old ones are superseded, preventing stale data from leaking into your agent's current worldview.

The Distillation Loop

We do not store text.
We extract truth.

Raw chat logs are noise. Aletheia acts as a cognitive filter, distilling human rambling into a clean, queryable lattice of facts.

Time-Awareness

I used to love coffee, but now I only drink tea. Aletheia does not hallucinate your old preferences. It updates your profile in real time.

Fact Distillation

Our engine automatically discards greetings and filler, keeping only the high-value semantic facts that actually matter for personalization.

"Hey! I just bought a white Mercedes!"

Raw Chat

Distillation Engine

Running: Rust Semantic Kernel v2

Semantic Fact: User owns White Mercedes

Committed to Long-Term Memory

The Human Touch

One brain,
infinite applications.

Our White Mercedes engine ensures your user's identity is not locked inside a single chat window.

The First Spark (May 12)

Hey! I just bought a white Mercedes! What should I do first?

GPT-4o detects: User Ownership → Vehicle: Mercedes (White)

Aletheia Ingests

Fact Integration

Fact: Owns Mercedes

Context: Initial Purchase

3 Months Later (Aug 20)

What was that maintenance tip for my car?

Claude 3.5 recalls: "For your white Mercedes, I recommend..."

Our Unique Edge.

Engineered for builders who need more than just a place to dump text files.

Multi-Model Continuity

Memory that follows the user, not the model. Switch from GPT-4 to Claude to Llama and Aletheia keeps the brain intact across every integration.

Fact Supersession

When life changes, Aletheia knows. If a user moves from NYC to LA, the old fact is marked as superseded so stale context stops leaking into answers.

Zero-Config Performance

Built with Rust as a single compiled binary. Deployment is fast and recall latency stays in the sub-100ms range without orchestration drama.

The Architecture of Truth

Sentient Memory Pipeline.

Aletheia is not just storage; it is a multi-stage cognitive processor that transforms raw noise into reliable agentic state.

IngestRaw Events

Distill & StoreCognitive Controller

HNSWBM25GRAPH

Final TruthGrounded Context

Intent-Aware Filtering

Automatically detects if the user is asking for numbers, preferences, or narrative history.

Neural Reranking

Applies a secondary precision pass to ensure the top-k candidates are semantically perfect.

Deterministic Compute

Computes aggregates (sums, counts) before delivery, preventing LLM arithmetic errors.

Interactive Graph

Sentient Memory Lattice.

Experience how Aletheia organizes memories. Drag nodes to interact with the underlying graph logic where new facts supersede the old.

Active Truth

Superseded Memory

Nodes represent discrete semantic facts, preferences, and entities stored within the Rust engine.

Red nodes indicate **superseded memories**—stale data that has been automatically invalidated by more recent truths.

Built for the
next decade of AI.

We did not just build a wrapper. We built a high-performance memory kernel from the ground up for safety and scale.

Coded in Rust

Ultimate memory safety and blazing-fast execution. No garbage collection pauses, just low-level performance where it matters.

Single Binary Deployment

No complex Docker chains. One file, zero configuration, instant memory synchronization across your stack.

Sub-100ms Latency

Human-like recall speeds that keep up with your fastest LLM workflows without turning memory into the bottleneck.

<100ms

Average Recall

Platform Surface

Built as a complete
memory stack.

Every layer from ingest semantics to production operations is implemented with one cohesive design system and runtime story.

Cognitive Extraction

Transform raw text into structured knowledge using integrated Neural and Symbolic extractors.

Neural Entity Extraction (BERT-NER)
Autonomous Relationship Discovery
Implicit Preference Detection

Metric Vault

Track and aggregate numeric truth (money, counts, distances) with absolute deterministic precision.

Deterministic Regex Extraction
B-Tree range aggregation
Exact Sum/Count Query API

Temporal Truth

The engine models memory as something that changes over time, not a static bag of embeddings.

Kind-aware TTL and decay
Fact supersession and invalidation
Graph-based version lineage

Developer Surfaces

SDK and HTTP entry points are designed to keep local-first workflows aligned with hosted deployments.

Graph Walking & Analytics APIs
Auth + key lifecycle support
OpenAI-Compatible Proxy Path

Runtime Snapshot

Current Build Profile

Aletheia is shipping as an integrated memory platform, not isolated feature demos.

engine: Aletheia
routes: /ingest /query/semantic /query/temporal /memory
indexes: hnsw + bm25 + graph lineage
policy: ttl + decay + supersession
sdk: python + javascript

production-mindedlocal-firstmodel-agnostic

Public Repositories

Core engine repository is private: Aletheia

Delivery Path

From prototype to production memory.

The product has a clear progression: ingest fidelity, retrieval intelligence, and operational reliability.

Phase 01

Ingest and Distill

Raw events are normalized, deduplicated, and expanded into durable memories with lineage.

Companion memories
Dedup table
Graph relationships

Phase 02

Retrieve and Rerank

Semantic and lexical candidates are fused, reranked, then filtered by temporal policy before response.

HNSW + BM25
Cross-rerank
RRF + policy filters

Phase 03

Ship and Operate

Teams deploy one memory engine surface from local bench runs to hosted multi-tenant workloads.

SDK parity
Benchmarked quality
Operational playbooks

Interactive Demo

Live Memory Simulation.

Experience Aletheia's real-time ingestion and recall loop. Store a fact, then retrieve it across model contexts.

Input & Warm-up

Ingestion Layer

Serverless Pulse

Ping the engine to reduce cold-start latency before testing the demo.

Message to Persist

Truth Recall

Retrieval Kernel

Ingest Latency

---

Query Latency

---

Retrieved Memory Hits

No memories retrieved yet. Ingest a fact first.

Book A Session

Schedule a 30-minute Aletheia walkthrough.

Discuss architecture, integration strategy, and production rollout for your memory stack.

Open Calendly Email Instead

Build Agents That
Actually Remember.

One binary, five memory substrates, zero lock-in. Start building persistent, self-improving agents today.

Get Started Free Book a Demo

Two Ways to Remember

Engine and Platform

Aletheia Core

Open Source Engine

The Rust-powered temporal memory engine that runs anywhere. Hybrid vector + BM25 search, knowledge graph traversal, deterministic analytics, and fact supersession — all in a single binary. No cloud dependency. No vendor lock-in.

▸Single binary — download and run
▸4 HNSW indexes + BM25F + redb KV + typed graph
▸Candle / ONNX embeddings, CPU or GPU
▸Embed in your stack, pitch to your customers

Read the Docs Contact Us

Aletheia Platform

Managed Cloud Service

A full SaaS experience on top of the core engine. Deploy clusters in one click, manage your team, track usage with analytics, explore knowledge graphs visually, and never worry about infrastructure.

▸One-click cluster provisioning — no config files
▸Stripe billing — pay as you go or flat-rate
▸Team management with invites and roles
▸Graph explorer, analytics, API playground

Get Started Free Learn More

The Aletheia Ecosystem

Integrate Memory Anywhere.

We provide the tooling to make persistent memory a first-class citizen in your development workflow, from local testing to global scale.

Memory Enginefor AI Agents