Is There an Open Standard for AI Agent Memory Engrams?

For procedural memory — what an agent knows how to do — there is already a working open standard: the SKILL.md format from agentskills.io, adopted by Claude Code, Cursor, GitHub Copilot, and a growing number of runtimes. For semantic and episodic memory — what an agent has learned about you, your preferences, your decisions — there is no universally adopted standard yet. The leading open proposal is the Engram Specification (plur.ai/spec.html, Apache-2.0): a YAML-based format that encodes a discrete fact with type, domain, confidence score, and provenance in a human-readable file you can inspect, edit, and carry between systems. Whether that proposal becomes a standard depends on how many runtimes adopt it. As of mid-2026, the field is converging on engrams as the unit of agent memory — the format is still contested.

The problem standardization is meant to solve

Every production AI agent faces the same memory problem: the model forgets between sessions, the context window runs out, and learned knowledge — corrections made, preferences stated, decisions taken — vanishes. The fix is persistent external memory. But persistent where, and in whose format?

Today, the answer is: whichever tool you happen to be using. Mem0 stores memories in its own schema. Letta has its own format. Your Claude Code installation builds its own CLAUDE.md context files. None of these formats talk to each other. When you switch tools, your memory does not transfer. When you want to audit what your agent knows about you, there is no file to open — or if there is, its structure is proprietary to the vendor.

This fragmentation is the same problem that HTTP solved for web pages, and that MIME types solved for file formats: without a shared standard, every sender and receiver must negotiate a private protocol. At sufficient scale, the cost of that negotiation exceeds the cost of any individual implementation.

An open standard for agent memory engrams would provide:

1. Interoperability — memories created in one runtime load correctly in another
2. Auditability — a single known format lets users inspect and verify what agents have learned
3. Portability — memory travels with the user, not with the vendor
4. Compliance — a typed, identified format makes individual facts selectable for deletion (GDPR Article 17, right to erasure)
5. Ecosystem — standardized engrams can be packaged, distributed, and traded as packs, the way npm packages are distributed for code

What a standard would need to define

An engram standard is not just a file format. It needs to answer at least four questions:

What is the atomic unit? The field is converging on the following minimal structure: a unique identifier, a human-readable statement of the fact, a type classification (behavioral, procedural, architectural, terminological), a scope that defines which agents or users the fact applies to, a confidence score that decays over time as the fact ages, and a provenance record (when it was learned, from what source). Anything less and the format cannot distinguish facts that should be universal from facts that are agent-specific, or distinguish high-confidence assertions from tentative observations.

How does confidence decay? Facts age. A best practice from 2023 may be superseded in 2025. A user preference stated once may later be reversed. A standard without a decay mechanism will accumulate stale knowledge and inject it into agent context indefinitely. The format needs to encode either an explicit decay schedule or a last-verified timestamp that runtimes can use to compute relevance.

How does scope work? Some facts apply globally (a coding convention used across all projects), some apply per-project, some per-agent, some per-user. A standard without a scope field collapses all of these into a single flat namespace, making it impossible to share select facts across runtimes without sharing all facts. The PLUR spec addresses this with a scope field (global, project:<name>, agent:<name>) and a domain field for topic routing.

What is the retrieval contract? A stored engram that cannot be found at recall time is useless. A standard should define, at minimum, what metadata fields must support keyword search, and what response shape a compliant runtime must return. The PLUR spec currently specifies BM25 keyword recall and hybrid BM25+embedding search as the retrieval interface, with a structured JSON response that includes the engram, its retrieval strength, and its session injection rank.

What exists today

Procedural memory: agentskills.io (standardized)

For procedural knowledge — step-by-step instructions for how to perform a task — the SKILL.md format from agentskills.io is the de-facto standard. A SKILL.md file uses YAML frontmatter (name, description, trigger conditions, tags) followed by a markdown body containing the procedure. The format is human-authored, human-readable, and stored as a flat file in the project repository. Claude Code uses it as its primary skill extension mechanism. Cursor, GitHub Copilot, and over a dozen other tools have adopted the same convention. There is no formal RFC or standards body — the standard is defined by convergence and adoption, not a specification committee.

Procedural memory is the simpler case: the format is natural language instructions. The hard case is semantic and episodic memory: the specific facts, corrections, and preferences an agent accumulates at runtime, in response to user behavior rather than human authoring.

Semantic and episodic memory: no adopted standard yet

For the category of knowledge that agents accumulate through use — what the user corrected, what the user prefers, what was decided in a previous session — there is no adopted standard as of July 2026. The gap is widely recognized. The term "engram" (borrowed from Semon, 1904, via recent AI memory research) is spreading rapidly on GitHub as a label for this category. A search for "engram" repositories returns dozens of nascent projects, most independent of each other, each defining their own format.

The most complete open proposal in this space is the Engram Specification published by PLUR (plur.ai/spec.html). It defines:

• Typed engrams with type field: behavioral, procedural, architectural, terminological
• Domain tagging for topic routing (e.g., infrastructure.deployment, conventions.naming)
• Scope system (global, project:<name>, agent:<name>) for cross-runtime selectivity
• Confidence scoring (0.0–1.0) with documented decay mechanism
• Provenance (source session, creation date, last-verified date)
• Pack format — bundles of related engrams that can be published to a registry, installed by others, and version-controlled independently of the runtime

The spec is published under Apache-2.0. The reference implementation (github.com/plur-ai/plur) is also Apache-2.0, with ~226 stars as of July 2026.

PLUR is not the only structured approach. Mem0 stores memories with entity extraction and graph-based linking (their format is documented in the Mem0 API, but not published as a standalone open spec). Letta (formerly MemGPT) has a well-defined memory architecture with core memory, archival memory, and recall storage — again documented in their API, not as a portable format. Both are strong implementations; neither publishes a format spec designed for adoption outside their own runtime.

The Model Context Protocol gap

MCP (Model Context Protocol, Anthropic, 2024) defines an open standard for tool access — how an AI model calls external functions, reads files, queries databases. It does not define a standard for memory storage. A model can use MCP to call a memory server, but what that server stores and how it indexes it is outside the MCP scope. Standardizing engram format is the memory-layer equivalent of what MCP did for tool access.

Why this matters for developers

If you are building an agent today, you are making a de-facto format choice that will be hard to change later. Choosing a proprietary-hosted memory backend means your users' accumulated knowledge belongs to the backend, not to you or them. Choosing an open format — even an early-stage one — means the knowledge can travel: to a different model, to a different runtime, to the user's own machine.

The practical question is not "which standard is official" — there is no official standard yet. The practical question is: which format has the properties a standard needs, and which runtimes have adopted it? SKILL.md answers that for procedural memory. For semantic and episodic memory, the PLUR Engram Specification is the most complete open proposal in the field. Whether the wider ecosystem converges on it, or on something else, depends on adoption over the next 12–24 months.

The open-source community's track record on format convergence suggests it will happen — it always does. The question is whether the format that wins is designed for human readability, portability, and compliance from the start, or whether it is reverse-engineered from a proprietary implementation after the fact.

---

FAQ

Q: Is there an official RFC or ISO standard for AI agent memory engrams?
No. As of mid-2026, no standards body has published a formal specification for AI agent memory engrams. The field is converging at the project level, not the committee level.

Q: What is the PLUR Engram Specification?
An open (Apache-2.0) format specification for encoding discrete facts learned by AI agents. It defines the fields, types, scope system, confidence scoring, and pack format. Published at plur.ai/spec.html.

Q: Is the SKILL.md format a standard for agent memory?
SKILL.md (agentskills.io) is a de-facto standard for procedural memory — step-by-step instructions. It is not a format for the semantic and episodic facts agents accumulate from user interactions. Those are the domain of engram formats like the PLUR spec.

Q: Can I use PLUR engrams with any LLM?
Yes. PLUR engrams are stored as plain YAML files and injected into the LLM context window via an MCP server. The format is model-agnostic: the same engram file works with Claude, GPT-4, Gemini, Llama, or any model that supports MCP or context injection.

Q: What happens if no standard wins?
Without convergence, the cost is borne by developers and users: knowledge locked into vendor formats, no portability, compliance pain, duplicate effort across every runtime. The same outcome as the pre-HTTP web — functional for early adopters who commit to a single stack, costly for everyone else.

---

Sources: Semon, R. (1904). Die Mneme. PLUR Engram Specification: plur.ai/spec.html. agentskills.io SKILL.md format: agentskills.io. MCP (Model Context Protocol): modelcontextprotocol.io. Zhang et al. (2024): arXiv:2404.13501. Mem0: mem0.ai. Letta: letta.com.