NewThe memory engine for autonomous AI agents

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

Core Primitives

Engineered for data sovereignty and compliance.

Explore documentation
Erasure

Verifiable Physical Erasure

Active byte zeroization of vector float payloads and off-heap text buffers, backed by tamper-evident SHA256 receipt tokens.

Encryption

Per-Namespace AES-256-GCM

Authenticated envelope encryption with volatile key drop zeroization and enterprise KMS key wrapping (AWS, GCP, Vault).

Ingestion

Local ONNX Extraction

In-process entity and relation extraction via GLiNER and GLiREL with local embeddings. Zero model API calls on writes by default.

Detailed architectural proof points and verification mechanisms
The Problem

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:

01

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.

02

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.

03

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.

04

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.

Lifecycle

The Four Stages of Memory Lifecycle

ebbmem manages the entire lifecycle of agent context through four deterministic stages from local capture to physical erasure:

01In-Process ONNX

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.

Input Dialogue→In-Process ONNX→Vector Slab
02AES-256-GCM + BYOK

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.

Namespace Key→AES-256-GCM Envelope→KMS BYOK
03Continuous Retention

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.

04Byte Zeroization + SHA256

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.

Zeroization: 0x00→SHA256 Receipt→Audit Verified
Architectural Proof

Verified Architectural Capabilities

Every capability in ebbmem is implemented in production code and substantiated by verified technical mechanisms:

Proof Point 01

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.

Proof Point 02

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.

Proof Point 03

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.

Proof Point 04

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.

Applications

Enterprise & Developer Use Cases

From sovereign air-gapped clusters to local developer CLI tools, ebbmem delivers compliant, cost-predictable memory:

Case 01

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.

Case 02

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.

Case 03

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.

Case 04

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.

Case 05

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.

Quickstart

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.

  • 01
    Embedded LibraryNative Python extension (pip install ebbmem) and Rust crate (ebb-memory). Runs inside your process against bundle.mem.
  • 02
    Containerized ServerSingle container runs HTTP API on port 8320 with embedded SQLite control plane, or PostgreSQL for clustered deployments.
  • 03
    Model 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}")
Memory model

Episodes become knowledge.

Episodic

What happened, and when

Time-stamped events from conversations and tool calls, scoped per user and per agent. They decay unless they are recalled.

09:14Booked Lisbon trip for May 12
09:16Asked for metric units
MonMentioned a peanut allergy
Mar 2Tried the beta search tool
Semantic

What stays true

Facts consolidated from repeated episodes. Higher stability, linked to their sources.

S↑Prefers metric units
S↑Allergic to peanuts
S↑Travelling to Lisbon in May
FAQ

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.

Enterprise

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.