Say It Once

Persistent memory for AI agents

The Blank Slate Problem

Your AI agent forgets everything the moment the session ends

engram-lite (kenotron-ms/engram-lite) is lightweight persistent vector memory for AI agents — an Amplifier module and Claude Code plugin that recalls silently across sessions, so you say something once and it sticks.

First, proof that it's real — then why the blank slate hurts, and how memory fixes it.

It's Real, It's Built

Not a concept — a working system you can install today

46 commits of Python, a 55-function test suite, shipping as both an Amplifier module and a zero-install Claude Code plugin. Version 0.1.0.

So the promise is credible. But why does an agent need memory at all?

46

commits, all by one developer

~4,015

lines of Python (2,851 in the core module)

55

test functions in tests/

2

homes: Amplifier module + Claude Code plugin

The Recurring Tax

Every session starts from zero — so you re-explain yourself, again and again

An agent is sharp within a session and can absorb your preferences and decisions on the fly. But it wakes up a blank slate every time. engram-lite classifies what matters into seven content types so it can be recalled later.

fact · preference · decision · event · skill · entity · relationship

How Memory Persists

Two layers carry the memory across every session

A durable store underneath, a hot context surface on top — the one architectural idea the whole system leans on.

Storage is only half of it. The other half is that you never see it happen.

Layer 1 — SQLite vector DB Durable storage: capture() writes to the DB / vector layer. A user-private DB in ~/.engram/ and a project-shared DB in <project>/.engram/.

Layer 2 — LLM-authored MEMORY.md The hot-context surface for memory injection. The LLM writes the full MEMORY.md content via a memory-index write action.

How It Feels Invisible

A silent loop uses memory automatically — and never announces it

Injected via platform hooks, engram-lite operates through a behavioral loop that runs on every turn. Its protocol is explicit: use both layers automatically and silently. Never announce memory operations to the user.

That's the feel. Next: is recall actually smart enough to surface the right thing?

1

RETRIEVERelevant memories are pulled in before the agent responds.

2

RESPONDThe agent answers with that context already in hand.

3

CAPTUREA reminder is injected before each LLM call to store what's worth keeping.

Recall That Actually Finds Things

Dual-route retrieval — not a naive lookup

Recall runs two routes and a router picks between them (auto / vector / graph / hybrid / keyword). The architecture is a clean-room adaptation of the Mnemis paper (arXiv:2602.15313) — no copied code, only ideas.

So the memory is smart enough that saying it once is enough.

System-1 — fast fused search Vector KNN + BM25 full-text (FTS5), fused with Reciprocal Rank Fusion (rrf, k=60).

System-2 — graph traversal Hierarchical graph traversal for connected recall (Mnemis global selection).

The Payoff

Say it once — and it sticks

The silent RETRIEVE→RESPOND→CAPTURE loop remembers across sessions and never announces a thing. Nine memory_* tools — capture, recall, search, update, forget, relate, graph_explore, stats, index — are exposed via native function calling / MCP, so the agent quietly remembers across every future session.

You stop re-explaining. The agent carries what you told it forward.

What To Keep

A small, sharp blueprint for giving any agent memory

Built clean-room in about two days by a single developer, Ken Chau, engram-lite is honest about its maturity: early alpha. The value isn't the star count — it's the pattern.

Two silent layers, a hooked loop, dual-route recall — reusable anywhere agents forget.

Built in~2 days, 2026-03-03 to 2026-03-05

ByKen Chau — sole contributor, 46 commits

MaturityEarly alpha (Development Status :: 3 - Alpha, v0.1.0)

Embeddingsfastembed (ONNX, no PyTorch) by default

InstallZero-install for Claude Code via uvx

Sources

Research Methodology

Primary source: kenotron-ms/engram-lite (primary language Python) · Early Alpha · v0.1.0

Data as of: repo pushedAt 2026-03-05; commit history 2026-03-03 → 2026-03-05.

Commands run:

gh repo view kenotron-ms/engram-lite --json name,description,createdAt,updatedAt,pushedAt,primaryLanguage,stargazerCount,url
git rev-list --count HEAD (46 commits) · git shortlog -sne --all (46 by Ken Chau)
git log --reverse --format='%ai' (first / last commit dates)
git show faa7587 --stat (two-layer memory: DB + LLM-authored MEMORY.md)
grep -iE 'silent|never mention|two-layer' context/memory-instructions.md (silent protocol)
grep -riE 'fastembed|FTS5|BM25|RRF' amplifier_module_engram_lite/ (dual-route retrieval, rrf k=60)
grep -A1 '@mcp.tool()' amplifier_module_engram_lite/mcp/server.py (9 memory_* tools)
find . -name '*.py' | xargs wc -l (4,015 total LOC; 2,851 in core module)
grep -rhE 'def test_' tests/*.py | wc -l (55 test functions) · cat pyproject.toml (fastembed, entry points, alpha status)

Primary contributor: Ken Chau <kchau@outlook.com> — 100% of 46 commits (sole contributor).

Gaps & caveats: Tests were not executed this session (55 defs counted; commit messages cite 44 and 59 over time). README performance figures (System-1 <100ms, System-2 <300ms) are documentation assertions, not benchmarked, and are excluded here. README lists 8 tools; code registers 9 (memory_index omitted from README). Author metadata varies (pyproject: "Ken Chow <kenchow@microsoft.com>") — noted, not resolved. PyPI publication not verified. Stars: 0.