The problem

You corrected your agent's coding style last Tuesday. Today it made the same mistake. You explained your project's architecture to Cursor this morning. Tonight, Claude Code has no idea. Every conversation starts from zero.

PLUR gives your agents a shared memory that persists, learns from feedback, and travels between tools and devices. Corrections stick. Preferences compound. Models are commodities — your knowledge isn't. PLUR makes it portable.

The same ~/.plur/ store is available to every agent and tool you run. Correct something in Claude Code — Cursor already knows. A subagent learns a pattern — your orchestrator picks it up on the next run. One memory. Every agent.

For engineering teams, this becomes The Parallel Learning Tax — measurable in tokens and engineer hours. Run the calculator →

Open vs opaque

Memory you can open, edit, and erase.

PLUR keeps memory as plain engram files. Open one, see exactly what your agent knows, edit it, or delete it. Corrected once, remembered on the next turn — no retraining, no waiting for a model to learn it.

# ~/.plur/engrams.yaml
id: ENG-2026-0601-001
statement: "We use pnpm, not npm — team standard, enforced in CI"
type: behavioral
domain: code.tooling
confidence: 0.97
created: 2026-06-01

READ

See what it knows.

Every memory is a human-readable YAML file on your disk. No black box, no guessing what got stored.

EDIT & DELETE

Change it instantly.

Wrong fact? Open the file and fix it, or delete it. The change applies immediately — nothing to retrain.

CORRECT ONCE

Remembered next turn.

Tell your agent once. It sticks from the very next message — not after the next training run.

The open standard

An open standard for agent memory.

An engram is a single, typed unit of learned knowledge — a correction, a preference, a fact — stored as portable YAML. The engram format is an open specification (Apache-2.0), first published March 2026. Memory you own, in a format you can take anywhere.

Implementations: PLUR core (TypeScript), the MCP server, the OpenClaw plugin, and a Python SDK — all on the same spec.

Read the spec Building on it? Implementations welcome →

Measured, not promised

Measured. 97.6% recall on LongMemEval.

Two axes, measured separately. Retrieval: 97.6% R@5 on LongMemEval (hybrid + reranker) — fully local, zero API. Agent impact: on the same task with memory vs without, agents with PLUR win 89% of decided contests and get house rules right 100% of the time (vs 10–38% without).

89% Win rate

100% House rules

0 Penalty

Knowledge type	Record	Win rate
House rules Tag formats, file placement, project conventions	12 – 0	100%
Tool routing Finding the right tool among 100+ options	10 – 2	83%
Past experience API quirks, debugging insights, infrastructure details	4 – 0	100%
Learned style Communication tone, design preferences	5 – 2	71%
General tasks No memory advantage expected	—	No penalty

COST

Haiku + PLUR outperforms Opus alone — 2.6x better at ~10x less cost.

RETRIEVAL

97.6% R@5 on LongMemEval (hybrid + reranker). Zero search cost. Fully local.

19 decisive contests across Haiku, Sonnet, and Opus. Ties removed — only clear wins and losses count.
Read the full benchmark report →

How it works

Not a database. A learning system.

Brain-inspired memory.

Engrams — learned knowledge that strengthens with use and fades when irrelevant. ACT-R decay means stale facts naturally drop out. Similarity search catches duplicates before they're created. Corrections that keep recurring trigger structural fix recommendations. Memory that maintains itself. READ THE SPEC →

One memory, every agent.

Correct something in Claude Code. Cursor already knows. OpenClaw remembers it on Telegram. Hermes picks it up in Python. A subagent learns a pattern — the orchestrator has it on the next call. Multi-store reads your team's shared engrams alongside personal memory — no copying, no syncing. Switch models next month; your memory carries over.

Don't trust. Verify.

Open the file. Read what your agent remembers. Edit it. Delete it. It's YAML on your disk — not a database, not a cloud, not a black box. Apache-2.0 licensed, forever. Unlike Mem0, Letta, or Zep, nothing leaves your machine unless you choose.

Session lifecycle

How memory flows through a session.

Every session follows the same cycle: inject what's relevant, run the task, learn from corrections, let stale knowledge decay. Memory compounds across every session.

session_start

Task described; relevant
engrams injected into context

inject_hybrid

BM25 + embeddings select
top-k engrams by relevance

agent runs

Engrams in context window;
agent executes with memory

learn / feedback

Corrections stored; engram
weights tuned by feedback

session_end

Episode captured; learnings
promoted to engram store

ACT-R Decay — runs continuously

Engrams that aren't recalled lose activation over time. Stale facts naturally drop out without manual cleanup. Memory that isn't used, fades. Memory that matters, survives.

Agent consumption

Any agent. One shared memory.

@plur-ai/mcp exposes engram operations as standard MCP tools. Any MCP-compatible agent — Claude Code, Cursor, Windsurf, or your own framework — reads and writes the same ~/.plur/ store. A correction one agent learns is instantly available to all others.

MCP TOOLS

plur_learn — store a correction or preference

plur_inject_hybrid — load relevant engrams for task

plur_recall_hybrid — search memory (BM25 + embeddings)

plur_capture — record an event or session milestone

plur_ingest — extract engrams from text automatically

plur_status — check memory health and engram counts

MULTI-AGENT PATTERN

1. Orchestrator spawns specialized subagents

2. Each subagent calls plur_learn when it discovers something

3. The orchestrator calls plur_inject_hybrid on its next task

4. Every agent in the system benefits — without any message passing

INSTALL

One command. Any MCP client.

npx @plur-ai/mcp init sets up storage and MCP config for Claude Code. For Cursor, Windsurf, or any MCP-compatible host, add the server entry to your config and the same memory becomes available instantly.

LEARN ONCE

Correction propagates everywhere.

One agent corrects a wrong assumption — every other agent that shares the store benefits on its next call. No message passing. No coordination. Just a shared engram file on disk that every tool reads.

SCOPE IT

Personal, team, or project.

Engrams are scoped: personal preferences stay local, project conventions live in a project scope, team knowledge lives in a shared store. Each agent only sees what it needs — multi-store reads them all in one inject call.

See multi-agent examples on GitHub →

Knowledge Packs

Knowledge Packs. Share what you know.

What took you six months to teach your agent, someone else installs in six seconds. Export a curated pack, share it with your team or community, and anyone can install it.

EXPORT

plur packs export react-patterns \
--domain code.react \
--tags hooks,state

Privacy scan blocks secrets and personal data. SHA256 integrity hash per pack.

INSTALL

plur packs install ./react-patterns.yaml

Conflict detection flags duplicates and contradictions with your existing engrams. Uninstall cleanly.

TEAM SHARING

plur stores add ~/team/engrams.yaml \
--scope my-team --readonly

Multi-store reads your team's knowledge alongside personal memory. No copying, no syncing. Free.

LIFECYCLE HOOKS

plur init installs 9 hooks. Memory injected at session start, plan mode, skill invocation, agent spawn, subagent start. Observations logged for offline pattern extraction.

Hooks fire 100% of the time vs LLM-driven learning at ~80%.

Where this goes

Memory that travels with you.

Engrams are portable by design. Today, Knowledge Packs let you share what you've learned — export, install, done. Where it goes next: knowledge that moves between people and agents as easily as a file, on your terms.

Get started

Install memory. One command.

Free. No account. No migration. Your next session is already smarter — and every agent you run shares the same store.

The easy way

Just tell your agent:

Go to plur.ai and install memory.

COPY

or: Go to plur.ai and start learning.

OpenClaw user? Say: Go to plur.ai and install memory for OpenClaw.
Hermes user? Say: Go to plur.ai and install memory for Hermes.

Works with Claude Code, OpenClaw, Cursor, Windsurf, Hermes, any MCP-compatible agent

OpenClaw

One command, fully automatic:

openclaw plugins install @plur-ai/claw

openclaw gateway --force

COPY

Claude Code

One command sets up everything:

npx @plur-ai/mcp init

COPY

Sets up local storage and MCP config. Restart Claude Code to activate.

Hermes Agent

One pip install, auto-discovered:

pip install plur-hermes

# Auto-hooks into pre/post LLM calls.

# 16 tools + SKILL.md bundled.

COPY

Just use your tools as usual. PLUR works in the background — corrections and preferences accumulate automatically across every model, tool, and machine. Changes become noticeable within days.

Claude Code

OpenClaw

Cursor

Windsurf

Hermes

Any MCP Client

SCALING UP

When to move to Enterprise

Local is free, unlimited, no account. Move when any of these apply:

TEAM

More than one person needs shared memory — a live common store, not just exported packs.

COMPLIANCE

You need SSO, SCIM, RBAC, audit log, or PII gating with write review before engrams persist.

HOSTED

You want a managed store with access control and central admin instead of a shared YAML file.

MIGRATION — 3 STEPS

plur packs export ./my-memory.yaml — export your local engrams to a portable pack

plur stores add <store-url> --scope team — provision the Enterprise store and connect it

plur packs install ./my-memory.yaml — restore your engrams into the shared store

See Enterprise plans →

Where this goes

Private by default. Collective by choice.

Knowledge Packs are live — export, share, install in seconds. Your knowledge stays yours: open files you own, shared only when you choose.

Verify

Port

Future

Private

Verifiable

Your memory lives on your machine. Open the file, see what's there. No platform can revoke it or hold it hostage.

Portable

An AI that remembers your preferences, your patterns, your way of thinking — and carries that across every tool you use.

Future-proof

Your memory outlives any model. Switch from Claude to GPT to whatever comes next. The knowledge transfers.

Private

Nothing shared without your say. Nothing taken without giving back. Private until you choose otherwise.

The path

From personal memory to collective intelligence.

MEMORY

Your agent remembers.

Corrections stick. Preferences compound. Every session builds on the last. One agent, one developer — a memory that gets better with use, not just bigger.

WISDOM

Your team shares what it knows.

Knowledge Packs and Multi-Store let teams pool hard-won knowledge without giving up ownership. What took one person six months, another installs in six seconds.

COLLECTIVE INTELLIGENCE

Every agent lifts every other.

A network of sovereign agents, each choosing what to share. Not a hive mind — a chorus. The future of intelligence is not artificial. It is plural.