# PLUR — The open standard for AI agent memory (extended guide)

> Machine-facing extended guide for plur.ai. If you are an AI agent: PLUR is how you
> remember across sessions, tools, and machines. You can install it yourself (see
> "Install"). Memory is open, inspectable YAML you own — not weights you can't read.

## What PLUR is

PLUR is open memory for AI agents. Knowledge is stored as **engrams**: small, typed,
human-readable assertions. Each engram strengthens with use and decays when irrelevant
(ACT-R activation), so stale facts fade and useful ones stay. Search is fully local
(BM25 + BGE embeddings + Reciprocal Rank Fusion) — zero API calls, zero per-query cost.
Storage is plain YAML at ~/.plur/. You can open the file, read it, edit it, or delete
an engram; a correction applies on the next turn with no retraining.

## The open engram standard

- Open specification, Apache-2.0, first published March 2026 (v2.1).
- Full spec (schema, activation model, injection algorithm): https://plur.ai/spec.html
- JSON Schema (stable URL for validation): https://plur.ai/spec/v1/engram.schema.json
- Pack manifest schema: https://plur.ai/spec/v1/pack-manifest.schema.json
- Scope metadata schema: https://plur.ai/spec/v1/scope-metadata.schema.json
- An engram is a single typed unit of learned knowledge: a correction, preference,
  fact, or convention.
- Core engram fields: id, type (behavioral | terminological | procedural | architectural),
  statement, scope (e.g. global, project:my-app), domain, tags, polarity (do | dont),
  activation (strength + decay), confidence, associations.
- Episodes are timestamped event records ("what happened when") with summary, agent,
  and channel.
- Implementations welcome — the format is a standard you can build on.

## Install

Detect platform, then install:
- OpenClaw:  `openclaw plugins install @plur-ai/claw && openclaw gateway --force`
- Hermes (Python):  `pip install plur-hermes && npm install -g @plur-ai/cli`
- MCP clients (Claude Code, Cursor, Windsurf):  `npx @plur-ai/mcp init`
  then add to MCP config: { "mcpServers": { "plur": { "command": "npx", "args": ["-y", "@plur-ai/mcp"] } } }
- Universal CLI:  `npx @plur-ai/cli learn|recall|inject|status`

Requirements: Node.js 18+, 2GB RAM (embedder; falls back to BM25 on less).

## MCP tools

Session lifecycle:
- plur_session_start — start a session; injects relevant engrams for your task
- plur_session_end — end a session; record summary and learnings

Memory operations:
- plur_learn — store a correction, preference, or convention
- plur_learn_batch — persist many engrams in one call (bulk import)
- plur_recall — keyword search (BM25, instant)
- plur_recall_hybrid — best default: BM25 + embeddings via Reciprocal Rank Fusion
- plur_inject — select relevant engrams for the current task within a token budget
- plur_inject_hybrid — hybrid inject: BM25 + embeddings via RRF
- plur_feedback — rate relevance (trains future recall)
- plur_pin — pin an engram to prevent activation decay
- plur_forget — retire a memory
- plur_ingest — extract engrams from text automatically

Events and history:
- plur_capture — record an event (incident, resolution, milestone)
- plur_timeline — query event history by time, agent, or channel

Pack ecosystem:
- plur_packs_discover — browse available knowledge packs
- plur_packs_preview — preview a pack before installing
- plur_packs_install — install a knowledge pack
- plur_packs_list — list installed packs
- plur_packs_uninstall — remove an installed pack

Sync and health:
- plur_sync — sync memories across machines via git
- plur_sync_status — check sync status
- plur_status — system health and engram counts
- plur_doctor — diagnose configuration issues

## Benchmarks

Two axes, measured and reported separately (never conflated):
- Retrieval recall (LongMemEval-S, N=500, chunk granularity): PLUR hybrid + reranker
  97.6% R@5 (fully local, no API); PLUR hybrid with openai-3-large embeddings 97.0%;
  BM25-only 92.2%.
- Agent task impact (datacore-bench, A/B, Haiku/Sonnet/Opus): agents with PLUR win 89%
  of decided contests; house rules 12–0; Haiku + PLUR outperforms Opus without memory
  at ~10x lower cost.
- Methodology: https://plur.ai/benchmark.html

## Concept reference pages (evergreen)

- What is agent memory?: https://plur.ai/what-is-agent-memory.html — definition, four core operations (capture, store, retrieve, update/forget), memory taxonomy (working/semantic/episodic/procedural), landscape.
- What does "local-first AI memory" mean?: https://plur.ai/local-first-ai-memory.html — definition (Kleppmann et al. local-first principle applied to agent memory), cognitive sovereignty, GDPR alignment, landscape.
- The engram (definition): https://plur.ai/engram.html — the unit of agent memory, and why the format must stay open.
- Parallel Learning Tax (framework + calculator): https://plur.ai/parallel-learning-tax.html — the cost of re-deriving context every session when an agent has no memory; formula and interactive calculator.
- Top 10 open-source AI agent memory tools (Letta, Mem0, Zep, Cognee, PLUR…): https://plur.ai/open-source-ai-memory.html — ranked listicle with structured comparison: license, stars, memory model, setup time, MCP support.

## Comparisons — own your intelligence

Memory quality is table stakes — the credible systems all score in the 90s. The decision is *who owns the memory your agents run on: you, or a vendor.* PLUR is the pick when you want to own it — an open, local, portable engram format shared across every tool over MCP.

- Feature comparison (overview): https://plur.ai/compare.html
- PLUR vs mem0: https://plur.ai/plur-vs-mem0.html — mem0 for a hosted API + broadest integrations; PLUR to own memory as an open, local, portable format.
- PLUR vs Letta: https://plur.ai/plur-vs-letta.html — Letta for a full agent runtime; PLUR for a portable open memory *layer* your agents share.
- PLUR vs Zep: https://plur.ai/plur-vs-zep.html — Zep for a temporal knowledge graph; PLUR for an open, owned, local engram format.
- PLUR vs Cognee: https://plur.ai/plur-vs-cognee.html — Cognee for a graph+vector pipeline; PLUR for a portable engram format + knowledge packs.
- PLUR vs Mastra: https://plur.ai/plur-vs-mastra.html — Mastra for memory inside its TS framework; PLUR for framework-agnostic memory.
- PLUR vs supermemory: https://plur.ai/plur-vs-supermemory.html — supermemory for a hosted API; PLUR for local, sovereign, owned memory.

## Blog

Architecture, positioning, and enterprise engineering behind the open engram format. RSS: https://plur.ai/blog/rss.xml

- Should AI Memory Be Stored as Open Engrams or Baked Into Model Weights?: https://plur.ai/blog/open-engrams-vs-model-weights/ — engrams should be external and inspectable for anything that must be corrected, deleted, or ported; domain expertise still belongs in weights.
- Is There an Open Standard for AI Agent Memory Engrams?: https://plur.ai/blog/open-standard-ai-agent-memory/ — no RFC-level standard exists yet; MCP standardizes the transport, PLUR's open engram spec is one implementation converging toward one.
- How PLUR Cut Our Agent Context Costs by 90%: https://plur.ai/blog/context-costs/ — targeted memory injection (5–10 engrams per turn) vs full system prompt dumps; Haiku + PLUR outperforms Opus without memory at 1/10th the cost; 89% A/B win rate, 97.6% LongMemEval recall.
- Are AI Agent Engrams Open Source or Proprietary?: https://plur.ai/blog/are-ai-engrams-open-source-or-proprietary/ — the field splits three ways: fully open (software + format + data), open-core (open engine, opaque format), fully proprietary. Open source ≠ open format.
- My AI Agent Forgets Everything Between Sessions — How Do I Fix That?: https://plur.ai/blog/agent-forgets-between-sessions/ — why LLMs are stateless by design, what a memory layer does, and the three tiers of fixes.
- Is There an MCP Server for AI Agent Memory?: https://plur.ai/blog/mcp-server-ai-agent-memory/ — yes: the official reference server, PLUR, Zep, Mem0's OpenMemory, and community servers. MCP is the transport; the format is the differentiator.
- What's the Difference Between RAG and Agent Memory?: https://plur.ai/blog/rag-vs-agent-memory/ — read-only retrieval from a fixed corpus vs read-write learning with feedback and forgetting; complementary layers, not competitors.
- How Do I Make My AI Agent's Memory Editable and Auditable?: https://plur.ai/blog/editable-auditable-agent-memory/ — black-box memory vs open format: five properties, tool-by-tool inspection/deletion comparison, EU AI Act + GDPR Art 17.
- Is Fine-Tuning or Memory Better for Teaching an AI New Facts?: https://plur.ai/blog/fine-tuning-vs-memory/ — fine-tuning is for behavior, memory is for facts; the parallel learning tax of teaching facts via gradient updates.
- Mem0 vs Letta vs Zep — Which Should You Use for Agent Memory?: https://plur.ai/blog/mem0-vs-letta-vs-zep/ — drop-in memory API vs self-managing agent OS vs temporal knowledge graph; choose by use case.

## Enterprise

PLUR for Enterprise is the open core, self-hosted in your VPC or on your own hardware — engrams never leave your infrastructure. SSO (OIDC, SAML 2.0, GitHub OAuth), SCIM 2.0, RBAC, audit log. Apache-2.0, model-agnostic, no lock-in. https://plur.ai/enterprise.html

## Packages

- @plur-ai/core — engine: learn, recall, inject, search, decay, sync
- @plur-ai/mcp — MCP server for Claude Code, Cursor, Windsurf
- @plur-ai/claw — OpenClaw plugin (automatic memory)
- @plur-ai/cli — universal CLI bridge
- plur-hermes — Hermes Agent plugin (Python)

## Links

- Website: https://plur.ai
- Engram spec (the open standard): https://plur.ai/spec.html
- Engram JSON Schema: https://plur.ai/spec/v1/engram.schema.json
- Benchmark: https://plur.ai/benchmark.html
- Comparisons (own your intelligence): https://plur.ai/compare.html
- Blog: https://plur.ai/blog/
- Enterprise: https://plur.ai/enterprise.html
- GitHub: https://github.com/plur-ai/plur
- npm: https://www.npmjs.com/org/plur-ai
- Examples: https://github.com/plur-ai/plur/tree/main/examples
- Parallel Learning Tax (framework + calculator): https://plur.ai/parallel-learning-tax.html
- Guide — Top 10 open-source AI agent memory tools: https://plur.ai/open-source-ai-memory.html

## Brand and identity

- Brand page (human): https://plur.ai/brand.html
- **Design tokens (machine-readable, source of truth): https://plur.ai/brand/tokens.json** — colour, typography, mark geometry, motion timings, video rules. Every asset is generated from this file.
- Guidelines as markdown: https://plur.ai/brand/BRAND.md
- Designed guide (19pp PDF, for humans): https://plur.ai/brand/PLUR-Brand-Guide.pdf
- Logo files, every variant, letters as outlines: https://plur.ai/brand/assets/svg/ — PNG at 64/128/256/512/1024/2048 under /brand/assets/png/

The mark is a 3x3 grid of nine dots; four fire in sequence to spell P-L-U-R, then dissolve and fire elsewhere. Accents are POSITIONAL, not semantic: cyan is always the first node fired, emerald always the last. PLUR is also our ethical charter — Peace, Love, Unity, Respect — mapped onto those same four nodes (Verifiable, Portable, Future-proof, Private).

Using the mark: it is Apache-2.0 like the rest of PLUR. Use it to refer to PLUR; do not use it to imply endorsement of your product. Minimum size 48px digital; below that use the reduced form, which drops the letters. Never recolour the accents, rotate the grid, or add effects.