Memory you can
actually forget.
Persistent context for AI agents with local zero-shot extraction, per-namespace envelope encryption, and verifiable physical erasure backed by cryptographic receipts.
Run as a single container with an embedded control-plane store, or as an embedded Python library. Quickstart
Engineered for data sovereignty and compliance.
Verifiable Physical Erasure
Active byte zeroization of vector float payloads and off-heap text buffers, backed by tamper-evident SHA256 receipt tokens.
Per-Namespace AES-256-GCM
Authenticated envelope encryption with volatile key drop zeroization and enterprise KMS key wrapping (AWS, GCP, Vault).
Local ONNX Extraction
In-process entity and relation extraction via GLiNER and GLiREL with local embeddings. Zero model API calls on writes by default.
The Four Bottlenecks of Agent Memory
Modern AI agents require long-term context to stay useful across sessions. However, current memory implementations introduce severe operational and compliance risks:
Append-Only Context Bloat
Most agent architectures treat memory as an append-only log or dump conversation turns into generic vector databases. Without active decay, outdated preferences, superseded facts, and transient tool outputs accumulate indefinitely. As the memory store grows, irrelevant context pollutes retrieval, diluting agent accuracy and inflating model prompt token consumption.
The Compliance Trap of Undeletable Memory
When users invoke privacy rights under regulations such as GDPR Article 17 or CCPA, standard vector databases only set soft-delete boolean flags or drop search index pointers. The underlying text and vector embeddings remain intact on disk slabs, memory caches, and database backups. When compliance audits arrive, engineering teams cannot produce verifiable, tamper-evident proof that personal data was physically destroyed.
Runaway Model API Bills on Ingestion
Typical memory frameworks call external frontier language model APIs on every incoming conversational turn just to parse entities, relationships, and user preferences before saving them. Scaling an agent fleet turns memory ingestion into a major recurring expense. In addition to high per-write model bills, every write operation incurs third-party network latency and exposes private dialogue to external cloud providers.
Logical Row-Filter Security Risks in Multi-Tenancy
Most multi-tenant memory solutions isolate customer data using logical software filters (such as WHERE tenant_id = ?) inside a shared database cluster. A single query bug, misconfigured access rule, or prompt injection can leak private customer memories across tenant boundaries. Furthermore, offboarding a customer requires slow row-by-row deletions rather than immediate cryptographic shredding.
The Four Stages of Memory Lifecycle
ebbmem manages the entire lifecycle of agent context through four deterministic stages from local capture to physical erasure:
Local Ingestion & Extraction
Dialogue turns and tool observations enter ebbmem through the HTTP API, embedded Python bindings, or Model Context Protocol (MCP). In its default configuration, an in-process extraction engine uses local zero-shot ONNX models to extract entities, relationships, and temporal references without calling external language model APIs. Local embedding models compute dense representations in the same process. Raw conversation text never leaves your infrastructure during extraction.
Encrypted Slab Storage
Extracted memories, vector embeddings, and associative links are written into unified storage slabs. Every namespace is sealed with authenticated AES-256-GCM envelope encryption. Plaintext Data Encryption Keys (DEKs) exist only in volatile system memory and are zeroized upon drop using compiler memory barriers. Wrapped keys integrate with Google Cloud KMS, AWS KMS, or HashiCorp Vault.
Associative Retrieval & Decay
When an agent queries memory, ebbmem performs multi-factor associative retrieval, combining dense vector similarity, lexical keyword matching, and relational graph traversal. Older, unreferenced memories naturally decay over time based on retention curves, while frequently accessed memories consolidate into enduring semantic knowledge. Your agents receive relevant context without requiring manual pruning routines.
Verifiable Physical Erasure
When an agent or user requests deletion, ebbmem physically overwrites vector float payloads and off-heap text buffers with zeros, unlinks relational graph connections, and logs a write-ahead purge event. For administrative or account-level offboarding, the engine cryptographically shreds the namespace encryption key and mints a tamper-evident SHA256 receipt token. You receive verifiable audit evidence that records were permanently destroyed.
Verified Architectural Capabilities
Every capability in ebbmem is implemented in production code and substantiated by verified technical mechanisms:
Verifiable Physical Erasure with Cryptographic Receipts
Soft deletes do not satisfy rigorous privacy audits. ebbmem provides active physical destruction across three distinct operational tiers:
Granular Memory Purge
Executing DELETE /api/v1/memory/{id}?purge=true physically overwrites vector float bytes and off-heap text storage with zeros, detaches Hebbian co-activation edges, splices temporal links, and logs a write-ahead purge record. The API returns a PurgeResultResponse reporting the exact count of zeroed bytes and unlinked references for audit disclosure.
Administrative Namespace Erasure
Calling POST /api/v1/admin/namespaces/{id}/erase purges all memories within a partition and generates an AdminErasureResponse. This includes a deterministic SHA256 erasure token computed from the tenant ID, namespace ID, timestamp, caller ID, and scrubbed record count. Built-in legal hold protections prevent accidental erasure while compliance holds are active.
Data Subject Erasure Cascade
User-level deletion requests (DELETE /api/v1/me and DELETE /api/v1/users/{id}) execute an atomic seven-step cascade: invalidating identity provider links, revoking active sessions and credentials, removing role grants, cryptographically shredding personal memory namespaces, and issuing an immutable ErasureReceiptResponse.
Per-Namespace AES-256-GCM Envelope Encryption with KMS BYOK
Software row filters are insufficient for multi-tenant isolation. ebbmem embeds authenticated envelope encryption directly into its storage layer:
Authenticated Symmetric Cipher
Payloads are encrypted using AES-256-GCM with a dedicated envelope structure in the cryptographic engine.
Volatile Key Management
Plaintext Data Encryption Keys (DEKs) reside exclusively in volatile memory buffers (SecureKey) that are explicitly zeroized upon drop using memory barrier primitives.
On-Disk Keyring Architecture
Namespace keyrings store only wrapped DEKs, algorithm identifiers, and fingerprints. Plaintext keys are never written to disk, and the engine refuses to start if a required keyring is missing.
Enterprise KMS Adapters (BYOK / CMEK)
Pluggable key providers connect natively to Google Cloud KMS, AWS KMS, and HashiCorp Vault.
Instant Cryptographic Shredding
Revoking a tenant key immediately drops and zeroizes cached DEKs, rendering existing on-disk ciphertext unreadable without rewriting underlying storage slabs.
Break-Glass Refusal on BYOK Namespaces
Emergency break-glass administrative access is refused on namespaces configured with customer-managed keys (BYOK) with HTTP 403 Forbidden.
Local ONNX Extraction with Zero Model API Calls by Default
Eliminate recurring third-party model bills and data egress on memory writes:
Default In-Process ONNX Models
In its default configuration, ebbmem uses local zero-shot ONNX models (GLiNER for entities and GLiREL for relations) alongside local embedding models (FastEmbed) running directly in-process via ONNX Runtime.
Zero Per-Write Token Bills
Memory extraction occurs locally on host infrastructure, eliminating per-token model API costs on conversational writes.
Zero Third-Party Data Egress
Sensitive user dialogue is processed entirely within your infrastructure perimeter, preventing raw text transmission to external model vendors during extraction.
Deterministic Processing
Combines zero-shot classification with deterministic temporal date resolution to ensure consistent extraction without prompt drift.
Optional Language Model Mode
For systems requiring generative consolidation or open-ended extraction, an optional language model extraction backend can be enabled via configuration (extractor.mode: "llm" and require_llm: true), supporting providers such as Ollama, OpenAI-compatible APIs, and Google Gemini.
Self-Hostable Single Container or Clustered Deployment
Run persistent agent memory without the overhead of complex database infrastructure:
Embedded In-Process Engine
Import ebbmem directly into your applications as a native Python extension (pip install ebbmem) or Rust crate (ebb-memory). Storage operates against a single preallocated slab file (bundle.mem) with zero database daemons required.
Unified Workstation Container
Launch the single ebbmem container with docker compose up -d using the root Docker Compose manifest, exposing the REST API on port 8320 with an embedded SQLite control plane by default.
Model Context Protocol (MCP) Server
Run the standalone ebb-mcp --stdio server to provide local memory integration for agent tools such as Claude Desktop, Cursor, and Goose over standard input/output.
Cloud & Cluster Orchestration
Deploy to Kubernetes using production Helm charts, or automate deployment to cloud virtual machines via Terraform manifests. For clustered deployments, ebbmem uses PostgreSQL for control-plane metadata and distributed write leases.
Enterprise & Hosted Deployments
Contact us for enterprise support and dedicated hosted options.
Enterprise & Developer Use Cases
From sovereign air-gapped clusters to local developer CLI tools, ebbmem delivers compliant, cost-predictable memory:
Privacy-Conscious Customer Support & Conversational Agents
Customer support copilots must recall user history, account details, and past issues across multiple support sessions to prevent repetitive questions. When a customer closes their account or requests data deletion, the platform triggers ebbmem's user erasure cascade (DELETE /api/v1/me), physically wiping conversational slabs, cryptographically shredding personal namespaces, and returning an auditable SHA256 receipt for compliance records.
Multi-Tenant Enterprise SaaS Copilots
Enterprise software providers delivering AI assistants to multiple corporate clients must ensure strict data boundaries. Using ebbmem's per-namespace envelope encryption with Customer-Managed Encryption Keys (BYOK via AWS KMS, GCP KMS, or HashiCorp Vault), each enterprise client retains exclusive control over their key material. When a corporate customer offboards, revoking their master key instantly shreds all historical tenant memory without requiring database downtime.
Air-Gapped & Sovereign Enterprise Environments
Defense, intelligence, and regulated enterprise environments operate within isolated virtual private clouds (VPCs) or air-gapped data centers with zero outbound internet access. By relying on local zero-shot ONNX models and local embeddings in its default setup, ebbmem ingests, indexes, and retrieves agent memory entirely on local CPU or GPU nodes without sending a single byte to external model APIs.
Autonomous Developer Tools & Local IDE Workflows
Developer environments, command-line coding agents, and local IDE assistants need persistent memory of coding patterns, repository conventions, and recent debugging sessions. Running as an embedded Python library or a zero-install Model Context Protocol (MCP) server over stdio, ebbmem stores context locally in a single file slab without requiring developers to manage local PostgreSQL, Redis, or vector database instances.
Regulated Healthcare & Financial Advisory Assistants
Clinical and financial advisory assistants handle sensitive patient histories and confidential wealth management records. ebbmem provides deterministic date-anchored extraction, authenticated AES-256-GCM encryption at rest, and granular legal hold controls (POST /api/v1/admin/namespaces/{id}/legal-hold) that freeze data during pending audits while enabling verifiable physical destruction once statutory retention periods expire.
Start building in minutes.
Run ebbmem in-process as a Python library, launch the single container with Docker Compose, or connect local AI tools via the Model Context Protocol (MCP). See the client SDKs and documentation.
- 01Embedded LibraryNative Python extension (pip install ebbmem) and Rust crate (ebb-memory). Runs inside your process against bundle.mem.
- 02Containerized ServerSingle container runs HTTP API on port 8320 with embedded SQLite control plane, or PostgreSQL for clustered deployments.
- 03Model Context Protocol (MCP)Run ebb-mcp --stdio over standard input/output for zero-install integration with local agent tools.
# Install the embedded engine directly
pip install ebbmem
# Initialize in-process engine backed by a single file slab
import ebbmem
engine = ebbmem.EbbEngine(data_dir="./data")
# Ingest an observation without external LLM API calls
engine.remember(
content="User prefers metric units and Python for all examples",
namespace="agent-workspace"
)
# Recall relevant context with associative scoring
results = engine.recall(
query="formatting preferences",
namespace="agent-workspace",
limit=5
)
for memory in results:
print(f"[{memory.score:.2f}] {memory.content}")Episodes become knowledge.
What happened, and when
Time-stamped events from conversations and tool calls, scoped per user and per agent. They decay unless they are recalled.
What stays true
Facts consolidated from repeated episodes. Higher stability, linked to their sources.
Technical & Compliance FAQ
Detailed answers regarding architecture, local extraction, encryption, and verifiable data erasure:
01How does ebbmem achieve verifiable erasure compared to standard vector database deletion?
Standard vector databases handle deletion by flagging rows with tombstones or dropping index pointers, leaving raw vector arrays and text snippets intact in storage slabs and backups until background compaction occurs. ebbmem's memory purge endpoint (DELETE /api/v1/memory/{id}?purge=true) actively overwrites vector float payloads and off-heap text buffers with zeros, detaches relational graph edges, and logs an immutable write-ahead purge event. The API returns a PurgeResultResponse detailing exact zero-wiped byte counts, and administrative namespace erasures produce a deterministic SHA256 receipt token computed across tenant ID, namespace ID, timestamp, caller ID, and scrubbed record counts.
02Does ebbmem require a language model API call for every memory write?
No. In its default configuration, ebbmem operates with zero language models in the write loop. It uses local zero-shot ONNX models (GLiNER for entities and GLiREL for relations) alongside local embedding models (FastEmbed) running directly in-process via ONNX Runtime. This eliminates third-party model API bills, eliminates data egress, and provides predictable extraction latency. For teams that specifically want generative language model extraction, an optional language model backend can be enabled via configuration (extractor.mode: "llm").
03What databases or storage services are required to run ebbmem?
In embedded mode (pip install ebbmem or the ebb-memory Rust crate), ebbmem runs inside your application process against a single storage file (bundle.mem) using its native vector index and graph storage. In standalone server mode, the root docker-compose.yml launches a single container whose control-plane store defaults to an embedded SQLite file (ebb_control.db). For clustered or Kubernetes deployments, ebbmem uses PostgreSQL for control-plane metadata and distributed write leases.
04How does per-namespace encryption at rest work with customer keys (BYOK)?
ebbmem encrypts data payloads using authenticated AES-256-GCM envelope encryption. Each namespace is assigned an independent Data Encryption Key (DEK). Plaintext DEKs exist only in transient volatile memory buffers (SecureKey) that are zeroized upon drop using memory barrier instructions. The encrypted DEKs are wrapped using a master Key Encryption Key (KEK) managed in Google Cloud KMS, AWS KMS, or HashiCorp Vault. Revoking the master KEK immediately renders the namespace ciphertext unreadable, providing instant cryptographic shredding.
05Can administrators bypass customer KMS keys to inspect private memory namespaces?
No. Emergency break-glass administrative access is refused on namespaces configured with customer-managed keys (BYOK). If an administrative caller attempts break-glass inspection on a BYOK-encrypted namespace, the server rejects the request with HTTP 403 Forbidden (EBB-100-AUTH-004).
06How does memory decay work, and do I need to run manual cleanup jobs?
ebbmem implements continuous memory decay directly inside its retrieval kernel. Each stored trace has an initial retrievability score that naturally declines as time elapses without access. When an agent recalls a memory, that memory trace is reinforced and its stability increases. Memories that are never accessed fade below retrieval thresholds automatically. Space reclamation can be triggered via the vacuum endpoint (POST /api/v1/memory/vacuum) or automated background compaction.
07Is ebbmem certified GDPR compliant?
Software alone cannot be certified as GDPR compliant, because compliance depends on organizational policies, data processing agreements, and operational controls. ebbmem provides the foundational technical primitives necessary to support compliance with data privacy mandates, specifically GDPR Article 17 (Right to Erasure) and CCPA deletion obligations. These primitives include physical byte zeroization, auditable SHA256 erasure tokens, atomic user identity cascades, and verifiable data export endpoints (GET /api/v1/me/export).
08Can ebbmem run on standard CPU instances without dedicated GPUs?
Yes. The default local ONNX models and FastEmbed embedding models used by ebbmem are quantized and optimized for CPU execution. They run efficiently on standard developer workstations, cloud virtual machines, and lightweight container instances without requiring specialized GPU hardware.
09What deployment options and hosted services are available today?
ebbmem is fully self-hostable today through Docker Compose, embedded Python and Rust libraries, standalone Model Context Protocol (MCP) servers, and Kubernetes Helm charts. Details regarding managed cloud availability, hosted clusters, and commercial licensing are available upon request.
Ready for verifiable agent memory in your private cloud?
Deploy sovereign memory infrastructure with customer-managed encryption keys (BYOK), verifiable erasure receipts, and dedicated enterprise support.
Customer-Managed Keys (BYOK)
Per-namespace AES-256-GCM envelope encryption with pluggable KMS adapters for AWS KMS, Google Cloud KMS, and HashiCorp Vault.
Verifiable Deletion Receipts
Active byte zeroization of float payloads and text storage, confirmed with deterministic SHA256 receipt tokens for compliance audits.
Sovereign & Air-Gapped Operation
Run entirely within your VPC or bare-metal environment with local ONNX extraction and zero outbound model API calls by default.