engram-lite is a local, conditioned memory layer for AI agents that serves each agent relevant facts based on persona, domain, and task, with zero LLM calls and full replayability.

Stars

28

7-day growth

No data

Forks

10

Open issues

0

License

Apache-2.0

Last updated

2026-07-06

AI repository intelligence
FR-AI / ANALYSIS

Why it is worth attention

It solves a critical problem of flat shared memory causing hallucinations, demonstrated by doubling task success (40% to 80%) and cutting hallucination to a third, while requiring no cloud infrastructure or LLM calls.

Who it is for

  • Developers building AI agents with Python
  • Hermes agent users needing persistent memory
  • Claude Code or OpenClaw plugin adopters
  • Researchers studying agent memory systems

Use cases

  • Serving on-call SRE agents with alerts, traces, and runbooks while keeping irrelevant information out
  • Providing restart-proof memory for multi-agent systems on a single machine
  • Integrating with Hermes, Claude Code, or OpenClaw for automatic memory capture and retrieval
  • Benchmarking memory system performance against LoCoMo and internal CAMP-Bench

Strengths

  • Conditioned serving eliminates cross-domain leaks and hallucination from irrelevant memory
  • Zero LLM calls for both capture and serving, making it fast and cost-free
  • Self-cleaning, explainable forgetting, and deterministic replay for debugging
  • Plugs into multiple agent frameworks with minimal setup (pip install or one command)

Considerations

  • Single-machine only; team/hosted edition (engram-core) not yet available
  • Requires a local embedding model (no cloud inference)
  • CAMP-Bench results are internal and not independently replayable (LoCoMo results are external)

README quick start

engram-lite

Local memory for AI agents, served by persona, domain, and task. Survives restarts. One machine, many agents.

Most agent memory is a shared pile: every agent gets the same top-k for the same query. In our benchmark (methodology below), an agent fed flat shared memory hallucinated more than an agent given no memory at all. Serving each agent the memory that fits who it is (its persona, its domain, the task in front of it) doubled task success (40% to 80%) and cut hallucination to a third.

And the memory layer never calls an LLM. On LoCoMo — the long-conversation memory benchmark — engram-lite scores J 68.3 with zero LLM calls and $0 to build the memory. The protocol, footnotes, and the full comparison against the leading LLM-based memory systems live in benchmarks/locomo/.

engram-lite is that serving layer, small enough to run on your laptop:

  • Conditioned serving. Register a profile per agent (persona / domain / scope). The same question serves your on-call SRE agent the alert, the trace, and the mitigation runbook, and serves your release agent the deploy, the rollback, and the freeze policy. Out-of-lane questions correctly serve nothing.
  • Restart-proof. Everything is stored in a single SQLite file. Your agent can restart tomorrow and pick up exactly where it left off.
  • Self-cleaning. A salience gate skips junk (code, command output, questions). New facts are de-duplicated, updates supersede old versions, stale facts expire, and the store stays bounded.
  • Zero infrastructure. No server, no cloud, no accounts, no telemetry. SQLite plus a local embedding model. pip install and you are running.
  • Explainable forgetting. Every drop, merge, truncation, and abstention is recorded with the rule that fired (Memory.decisions()). "Why don't you remember X?" has an answer — something an LLM-written memory can't give you, because its keep/drop decisions live inside model weights.
  • Deterministic and replayable. Same transcript in, same memory out — byte-identical across rebuilds. Memory failures can be diffed, bisected, and regression-gated like any other bug.
  • Plugs into what you build with. A Hermes memory provider, a Claude Code plugin, an OpenClaw plugin, or three lines of Python — all shar

Description

Local Agentic Memory

Related repositories

Similar projects matched by category, topics, and programming language.

lopopolo
Featured
lopopolo GitHub avatar

harness-engineering

Harness Engineering is a methodology for improving coding agent outputs by carefully crafting the environment around them—providing curated context, tools, and executable constraints that encode an organization’s nonfunctional requirements and cumulative lessons.

AI & Machine LearningAI Agents
2,390
slvDev
Featured
slvDev GitHub avatar

esp32-ai

A 28.9 million parameter language model runs on an $8 ESP32-S3 microcontroller entirely on-device, generating simple stories at about 9.5 tokens per second.

AI & Machine LearningLarge Language Models
1,960
littledivy
Featured
littledivy GitHub avatar

mimic

mimic captures traffic from any iOS or web app and automatically generates a Python client library that lets you call the app's API like a regular library.

AI & Machine Learning
1,482