Give AI a memory.
Or use the agent that already has one.
Download Remy for a ready-to-use desktop AI workspace, or build your own agent with Aura Memory. The same persistent, explainable memory powers both paths.
Ready product
Meet Remy
Chat, research, create documents, run workflows, and inspect how the agent worked — with memory that survives every session.
See Remy and downloadMemory infrastructure
Build with Aura
Add persistent, versioned, explainable memory to your own agent. Local recall, governed correction, and no memory API calls.
Install Aura MemoryRemy turns the memory layer into a workspace.
You do not need to write code to benefit from persistent AI memory. Remy packages it into a desktop agent for real work — with every important action visible and under your control.
Memory that compounds
Remembers decisions, preferences, evidence, and past work across conversations.
Work you can inspect
Trajectory shows messages, model calls, tools, timing, and where a run succeeded or failed.
Workflows, not only chat
Run pipelines, automations, research, and repeatable tasks from one workspace.
A closed Agent Lab
Give Remy a goal and let it plan, create, verify, and return the finished artifacts.
Governable cognitive substrate
The model stays frozen. Aura changes instead — memory accumulates, beliefs form, patterns emerge. Adaptation is bounded, auditable, and operator-controlled at every step.
4-Level Memory Hierarchy
Working (hours) → Decisions (days) → Domain (weeks) → Identity (months+). Memories decay naturally and promote automatically based on access frequency and confidence.
Cognitive Pipeline
5-layer reasoning stack: Records → Beliefs → Concepts → Causal Patterns → Policy Hints. Each maintenance cycle builds higher-order understanding from raw memories — zero LLM calls.
SDR Indexing
Deterministic O(k) recall via Sparse Distributed Representations with Tanimoto similarity. Bitwise operations on 256K-bit vectors. Sub-millisecond search, zero garbage collection pauses.
Belief Formation
Records are automatically grouped into beliefs with competing hypotheses, confidence scores, and conflict detection. Epistemic update phase derives support/conflict from the memory graph.
Explainability & Provenance
explain_recall(), explain_record(), and provenance_chain() expose exactly why a memory was surfaced and how it was derived. Every adaptation stays auditable — operators can inspect, restrict, or purge.
Immutable Evidence Lineage
SHA-256 lineage binds every admitted claim to an immutable source revision and its exact byte span. Verification status and answer permission remain independent, explicit gates.
Deterministic Context Capsules
Build namespace-isolated, token-bounded hot context with selection reasons, omission counts, and a stable content hash. Blocked and superseded records are never surfaced.
Governed Adaptation
capture_experience() and ingest_experience_batch() enable bounded self-adaptation without model retraining. Risk scoring and purge/freeze controls keep autonomous plasticity operator-safe.
Encryption at Rest
ChaCha20-Poly1305 with Argon2id key derivation. Append-only binary storage ensures transactional data integrity and power-loss resilience across edge and cloud.
MCP Ready
Native Model Context Protocol server — works with Claude Desktop, Cursor, VS Code, and any MCP client out of the box. HTTP+SSE transport for Make.com and n8n. 11 built-in tools.
Cognitive Crystallization Process
From input to permanent memory — no LLM calls, no embedding API, no cloud. Pure deterministic computation in Rust.
Input Encoding
Text is converted into a Sparse Distributed Representation (SDR) — a 256K-bit vector via xxHash3. Deterministic, no neural model needed.
Anchor Check
Flash-Crystallization scans for safety-critical, emotional, or identity triggers. If detected, the record is immediately committed to user_core.
Resonance Search
Tanimoto similarity is computed against existing synapses via bitwise operations. O(k) complexity where k = active bits.
Store or Merge
Tanimoto > 0.75 triggers Synaptic Synthesis (merge into super-synapse). Tanimoto > 0.2 updates existing synapse. Below 0.2 creates new synapse in general layer.
Crystallization
Background process autonomously promotes memories from general to super_core to user_core based on semantic intensity, access frequency, and cross-contextual relevance.
Kinetic Decay
Low-stability records are pruned via entropy-weighted decay. Each DNA layer has its own retention rate. Power-loss resilient via append-only binary storage.
How Aura compares
Most agent memory solutions require LLM calls for basic operations and offer no auditability. Aura is a governable cognitive substrate — pure local computation with full operator control.
| Feature | Aura | Mem0 | Zep | Letta/MemGPT |
|---|---|---|---|---|
| LLM required | No | Yes | Yes | Yes |
| Embedding model required | No | Yes | Yes | No |
| Works fully offline | Partial | With local LLM | ||
| Cost per operation | $0 | API billing | Credit-based | LLM cost |
| Recall latency (1K records) | <1ms | ~200ms+ | ~200ms | LLM-bound |
| Binary size | ~3 MB | ~50 MB+ (Python) | Cloud service | ~50 MB+ (Python) |
| Memory lifecycle (decay/promote) | Via LLM | Via LLM | ||
| Trust & provenance | ||||
| Encryption at rest | ChaCha20 | |||
| Explainability (provenance chain) | ||||
| Governed adaptation (purge/freeze) | ||||
| Language | Rust | Python | Proprietary | Python |
Three lines to remember everything
Python SDK works with any LLM framework. Store, recall, done.
4-Level Memory Hierarchy
Memories decay naturally and promote automatically. The cognitive pipeline runs in the background, forming beliefs, concepts, and causal patterns — no LLM calls required.
Current session context. Recent messages, active tasks. Decays quickly unless accessed.
Choices and reasoning. Why you picked X over Y. Promoted from Working on repeated access.
Learned knowledge and code. Project context, technical facts, domain expertise.
Permanent preferences and traits. User core values. Protected from decay.
Give your own agent a memory.
Python 3.9+. Pre-built wheels for Linux, macOS, and Windows. Install locally in one line — no separate memory service required.
MIT License · Patent Pending (US 63/969,703) · Rust core
Built in Ukraine
Need commercial licensing or priority support?
View Pricing