The Open Engram Format

An engram is the smallest unit of agent memory: one atomic fact, stored as a human-readable record outside the model. An agent can recall it, an operator can read and edit it, and anyone can delete it. In the open engram format, each engram is a plain-text (YAML) entry — not a vector blob, not a model weight — which makes it inspectable, correctable, and provably erasable. This document defines the format so "engram" stays an open thing you own, not a proprietary thing baked into someone's model.

What an engram is

The word comes from cognitive science — the physical trace a memory leaves. Applied to AI agents, an engram is one discrete thing an agent has learned, recorded so it survives across sessions and across tools. The open format makes four properties non-negotiable:

1. Open / inspectable — you can read, diff, and version every engram. It's a file, not a number.
2. Instantly correctable — fix a single fact mid-conversation by editing one entry. No retraining.
3. Provably forgettable — delete the entry and the memory is gone, demonstrably (GDPR-grade erasure). You cannot prove erasure from model weights.
4. Owned — your data, your infrastructure. Memory follows the agent, not the vendor.

Why "open" is the whole point

There are two ways to give an AI long-term memory:

	Open engrams (this format)	Model-native memory (weights)
Form	A human-readable file per fact	Numbers baked into the model
Inspect	Read it	Cannot
Correct	Edit one line	Retrain
Delete	Remove the entry — provably	Cannot prove erasure
Portability	Moves across agents/tools	Locked to the model
Ownership	Yours	The vendor's

Model-native memory is convenient and unauditable. When a fact is wrong, you can't see it; when you ask for it to be forgotten, you can't prove it's gone. The open engram format exists so that the most personal asset an agent holds — what it knows about you — stays legible, fixable, and yours. Memory should be something you can open.

Anatomy of an engram

A minimal engram (fields as implemented in PLUR's live v2 schema; the full field reference, activation model, and search pipeline are in the Engram Specification):

id: ENG-2026-0626-001
statement: "The deploy key for datacore.one is at ~/.datacore/env/credentials/deploy_key."
type: procedural            # terminological | procedural | behavioral | architectural
domain: infrastructure.deploy
scope: project:plur
confidence: 0.9
provenance:
  source: session
  observed_at: 2026-06-26

• statement — one atomic fact. One engram, one claim.
• type — what kind of knowledge (a fact, a procedure, a behavior, an architectural decision).
• domain / scope — where it applies; how widely it should be recalled.
• confidence — how strongly it's held; can decay over time and be retrained by feedback.
• provenance — where it came from and when, so the memory is auditable, not anonymous.

Engrams are stored together in a plain file (e.g. engrams.yaml) you can open in any editor, put under version control, and carry between machines.

Engram vs. the alternatives

• Engram vs. a vector in a database — a vector is an opaque embedding; an engram is a readable fact with provenance and a type. Vectors power retrieval; engrams are the thing a human can actually read and govern.
• Engram vs. fine-tuning — fine-tuning bakes facts into weights you can't inspect, correct, or delete. An engram is instant, reversible, and inspectable.
• Engram vs. a chat-history log — a log is a transcript; an engram is the distilled, deduplicated lesson drawn from it.

FAQ

What is an engram in AI? One atomic unit of agent memory — a single learned fact stored as a human-readable record outside the model, so it can be recalled, edited, and deleted.

Are engrams open source? In the open engram format, yes — engrams are plain files you own and can inspect. (Model-native "memory" baked into weights is not open or inspectable.)

Can I delete an engram? Yes — remove the entry and the memory is provably gone. That's a core property of the open format and the basis for real (not best-effort) erasure.

What works with the open engram format? Any agent runtime that can read the files or speak to a memory server — e.g. PLUR exposes engrams over MCP to Claude Code, Hermes, OpenClaw, and Cursor.

Go deeper

• The Open Engram Standard — the formal, language-agnostic standard (RFC-2119 conformance terms): engram object, packs, .plur capsules, trust model, JSON Schemas
• The Engram Specification — the full format: schema fields, activation model, feedback loop, search pipeline, minimum viable implementation
• What Is Agent Memory? — the concept an engram is the unit of
• Are AI Agent Engrams Open Source or Proprietary? — the landscape, tier by tier

---