Plur
Open, local, YAML-based memory for AI agents — one shared memory for every tool.
A pragmatic open-source pick for teams tired of re-teaching multiple coding agents. The local YAML approach is genuinely transparent and free, but real-world value depends on how well the MCP integrations fit your stack. Choose it if you want inspectable, portable memory without cloud sync.
Verified 15d ago · liveness 64/100 · cite: rightaichoice.com/tools/plur
- Developers using multiple AI coding agents and want consistent memory
- Privacy-conscious individuals seeking local memory storage without cloud
- Teams sharing agent knowledge through portable Knowledge Packs
- Engineers building custom multi-agent workflows with MCP or Python SDK
- Non-technical users needing a GUI or managed service
- Users wanting real-time cloud sync across devices
- Those needing integrations with non-MCP agents like ChatGPT or Copilot
We scan live Reddit threads, YouTube comments, X posts, G2 reviews and other communities — and hand you an honest verdict in under a minute.
- Honest verdict, not marketing
- Real pros & cons from real users
- Attributed quotes with receipts
3 free scans · no card needed
Skip PLUR if you need a managed cloud solution with a web dashboard, auto-sync across devices, or official support — this is a local-first developer tool.
PLUR is free and open-source (Apache-2.0), making it the cheapest option for agent memory — no per-token fees unlike Mem0 or Zep. It costs engineering time to set up and maintain.
In short
Plur — Open, local, YAML-based memory for AI agents — one shared memory for every tool. Best for Developers using multiple AI coding agents and want consistent memory, Privacy-conscious individuals seeking local memory storage without cloud, Teams sharing agent knowledge through portable Knowledge Packs. Free to use.
What's new in Plur
Checked 6 days agoAcross the latest 9 updates: 9 feature updates.
What's the Difference Between Open Engrams and Model-Native Memory?
PLUR explains open engrams vs model-native memory: portability vs vendor lock-in.
OpenClaw has built-in memory now. Do you still need PLUR?
OpenClaw ships SQLite-backed memory, but PLUR remains useful for cross-tool and improving memory.
Giving DeepSeek Harness Persistent Memory (And What I Learned Writing a Plugin)
DeepSeek Harness plugin embeds memory in system prompt; PLUR discusses undocumented host-contract gotchas.
Mem0 vs PLUR: Which AI Agent Memory Layer Should You Use?
PLUR compares its local-first MCP server with Mem0's managed API for multi-user products.
What Is the Best Open-Source Memory Layer for LLM Agents?
PLUR compares Mem0, Letta, Graphiti, Zep, Cognee, LangMem, and itself on storage, retrieval, portability, MCP.
What Memory Layer Works with Cursor or Codex?
PLUR adds durable MCP memory to Cursor and Codex; corrections survive resets and travel across tools.
How to Choose a Memory System for Autonomous AI Agents
PLUR positions itself against Mem0 and Letta for autonomous agent memory, citing model-native memory failures.
Is AI Agent Memory GDPR Compliant? A Developer's Guide
AI agent memory storing EU data risks GDPR non-compliance; PLUR outlines three common violations and fixes.
Best Tools for Giving AI Agents Long-Term Memory (2026)
Compares Mem0, Zep, Letta, LangMem, and PLUR on retrieval pattern, LongMemEval scores, hosting, portability.
What people actually say about Plur — is it worth it?
We scanned public community sources for Plur on Jul 3, 2026 and could not establish that the discussion we found is about this tool rather than something else sharing its name. Our own analysis of that scan says the posts were off-subject. Rather than publish a sentiment score built on the wrong subject, we publish nothing here and re-run the scan.
Viability Score
How well maintained and how widely used is Plur? Built from what the vendor actually publishes (docs, changelog, tutorials, integrations, pricing), whether the site is live, and how much real users discuss it. How we calculate this
Last calculated: September 2026
How we score →Key Features
- Local-first YAML engram storage
- Human-readable and editable memory files
- Cross-tool persistence via MCP (Claude Code, Cursor, Windsurf)
- OpenClaw plugin integration
- Hermes agent integration
- DeepSeek Harness plugin
- ACT-R decay for forgetting stale facts
- Similarity search deduplication
- Structural fix recommendations from recurring corrections
- Knowledge Packs for export, share, install
- Privacy scan for secrets and PII
- SHA256 integrity hashing per pack
- Conflict detection on pack install
- Multi-store scopes (personal, project, team)
- MCP tools: plur_learn, plur_inject_hybrid, plur_recall_hybrid, plur_capture, plur_ingest, plur_status
About Plur
PLUR is an open standard and toolkit for persistent AI agent memory, stored as human-readable YAML files on your local disk. It's built for engineering teams juggling multiple coding assistants — Claude Code, Cursor, Windsurf, OpenClaw, Hermes, and any MCP-compatible agent — so corrections, preferences, and project conventions stick across every tool. No cloud, no black box: open each memory file, edit it, or delete it, and the change applies immediately. The engram spec is Apache-2.0, and the project ships a TypeScript core, an MCP server, plugins for OpenClaw and Hermes, a DeepSeek Harness plugin, and a Python SDK. PLUR works via a session lifecycle: relevant engrams are injected into context, agents act with that memory, corrections are stored and weighted, and stale facts fade via ACT-R decay — so memory maintains itself. Similarity search deduplicates new engrams, and recurring corrections trigger structural fix recommendations. Multi-store support scopes memory by personal, project, or team, and a single inject call reads across all scopes. Knowledge Packs let you export agent learnings into portable YAML bundles. Share a pack and anyone can install it in seconds, with a privacy scan blocking secrets and PII, SHA256 integrity hashing, and conflict detection that flags duplicates or contradictions with existing engrams. On benchmarks, PLUR claims 97.6% R@5 recall on LongMemEval with a hybrid+reranker approach that runs fully local, and an 89% win rate in decisive agent-task contests versus no-memory baselines. It positions itself as the open, local alternative to proprietary memory services like Mem0, Letta, or Zep — transparent, GDPR-friendly, and under your control.
Behind the Verdict
Most agent memory tools sell you a black box. PLUR sells you a folder — ~/.plur/ — with YAML files you can open in any editor. That's the whole pitch, and for a certain kind of engineer it's exactly right. If you've ever watched a coding agent repeat a mistake you corrected last week, PLUR's shared store across Claude Code, Cursor, and Windsurf feels like a relief. But it's not magic: the value compounds only if you actually wire up the MCP server and let corrections flow through plur_learn. Where PLUR shines is multi-agent setups. The multi-agent pattern — subagents call plur_learn on discovery, orchestrator calls plur_inject_hybrid next task — is clean and eliminates message-passing spaghetti. The DeepSeek Harness plugin and OpenClaw plugin extend that reach, though the DeepSeek plugin's undocumented host-contract gotchas (noted in a recent blog) mean you'll spend some time reading source. Now, the caveats. The benchmark claims — 97.6% recall, 89% win rate — come from PLUR's own report, and the win-rate numbers include a 'no penalty' category for general tasks, which is honest but muddies the headline. And OpenClaw's new built-in SQLite memory (announced August 2025) directly competes with PLUR for OpenClaw-only users; PLUR's counterargument focuses on cross-tool and long-term memory, which is fair but means you need at least two tools to feel the real benefit. There's no GUI, no cloud sync, no official support — this is a developer tool, full stop. If you're not comfortable editing YAML and running npx commands, pass. If you're an enterprise needing SLAs, pass. But if you're a team running multiple agents and you value inspectability over convenience, PLUR is worth a weekend experiment. The pricing is unbeatable: free, Apache-2.0, forever. Compare that to Mem0 or
Researching Plur? Get your full AI stack in 60 seconds.
Free, no signup — tell us your goal and get tools matched to your budget & existing stack.
Real-world workflow fit
Concrete scenarios for the personas Plur actually fits — and what changes day-one when you adopt it.
You correct Claude Code's coding style every day. Install PLUR's MCP server, run plur_learn after your correction, and the next session uses that engram.
Outcome: No more repeating corrections — your style persists across sessions, saving hours weekly.
Your team uses Cursor and Windsurf. Store project conventions as team engrams, share via Knowledge Packs, and all agents follow the same rules.
Outcome: Consistent code style across the team, less review friction, and new joiners ramp up faster.
You build a custom agent using the Python SDK. Inject relevant engrams at session start, capture episode learnings, and your agent improves over time.
Outcome: Your agent gets smarter with each task, reducing errors and boosts productivity.
Use Cases
- Correct your agent's coding style once and have it stick across Claude Code and Cursor
- Store project conventions (tag formats, file placement) so all agents follow them
- Document API quirks and debugging insights as shared team engrams
- Maintain a repository of preferred communication tones across sessions
- Track tool routing preferences among 100+ available tools without re-querying
Models Under the Hood
as of 2026-09-09
Limitations
- PLUR is a local-first agent memory layer that stores memory as human-readable YAML engram files on disk.
- It provides an open standard (Apache-2.0) and integrates with tools like Claude Code, Cursor, Codex, and OpenClaw via MCP.
- Memory is editable and portable across tools, but effectiveness depends on correction quality and memory coverage.
as of 2026-08-26
Verification history
We have re-verified Plur 7 times since . Each pass re-reads the vendor's own pages and re-checks every listed field against that evidence; passes where nothing had changed are marked as such.
- — re-verified summary, description, our verdict, our analysis, pricing model, pricing tiers, features, integrations, who it suits, who should skip it
- — re-verified summary, description, our verdict, our analysis, pricing model, pricing tiers, features, integrations, who it suits, who should skip it
- — re-verified summary, description, our verdict, our analysis, pricing model, pricing tiers, features, integrations, who it suits, who should skip it
- — re-verified summary, description, our verdict, our analysis, pricing model, pricing tiers, features, integrations, who it suits, who should skip it
- — re-verified summary, description, our verdict, our analysis, pricing model, pricing tiers, features, integrations, who it suits, who should skip it
- — re-verified summary, description, our verdict, our analysis, pricing model, pricing tiers, features, integrations, who it suits, who should skip it
Showing the 6 most recent of 7 verification passes.
Free to cite with attribution — this page re-verifies continuously.
12-month cost
Project the real annual outlay, including the implied monthly cost when only an annual tier is published.
Vendor list price only. Add-on usage, seat overages, and contract minimums are surfaced under Hidden costs & gotchas.
Plans compared
For each published Plur tier: who it actually fits, and what it adds vs. the previous tier. Cross-reference the cost calculator above for projected annual outlay.
Open Source
$0
Ideal for
Developers and teams who want free, local, inspectable AI memory with no vendor lock-in
What this tier adds
Free and open-source — includes all core features: MCP server, Python SDK, Knowledge Packs, and local storage
Where the pricing makes sense
The company stage and team size where Plur's pricing actually pencils out — and where peers do it cheaper.
PLUR is free and open-source (Apache-2.0), making it the cheapest option for agent memory — no per-token fees unlike Mem0 or Zep. It costs engineering time to set up and maintain.
Setup time & first value
How long it actually takes to get something useful out of Plur — broken out by persona, not the marketing-page minute.
Within 15 minutes: install the MCP server, add it to your agent's config, and start learning. A few hours to organize your engrams and set up team scopes.
Switching to or from Plur
How to bring data in from common predecessors and how to get it back out — written for the switcher, not the buyer.
- →From Mem0 or Zep: export your memories as YAML engrams and import them via the Python SDK
- ↗To Mem0 or Zep: manually port your memories since formats differ
Integrations
Resources & Guides
Tutorials & Learning
YouTube returned 6 videos for “Plur”, and we withheld 6: 6 could not be judged, because “Plur” is a single word that other videos use for other things. We are showing none, because we could not prove any of them are about Plur.
Official links
Tools that pair well with Plur
Common stack mates teams adopt alongside Plur, with the specific reason each pairing earns its keep.
Windsurf
Orchestrate fleets of local and cloud coding agents from one AI-native IDE.
Vercel
Vercel deploys web apps and AI agents with Git-based CI/CD, global edge delivery, and sandboxed agent infrastructure.
Poolside AI
Open-weight agentic coding models — Laguna XS 2.1 and Laguna S 2.1 — built for secure on-prem and air-gapped enterprise AI.
Featured Head-to-Head Comparisons
Plur vs Spider Cloud
Plur and Spider Cloud serve entirely different needs: Plur is a free, open standard for cross-tool AI agent memory (YAML engrams) that eliminates cloud dependency, while Spider Cloud is a freemium web crawling/scraping API with a Rust engine and AI-powered extraction. If you need persistent, inspectable memory across multiple coding agents, choose Plur. If you need to feed real-time web data into RAG pipelines or LLM workflows, Spider Cloud is purpose-built for that.
Plur vs Temporal Ai
For teams needing reliable, crash-proof execution of multi-step workflows—especially AI agents that must survive failures—choose Temporal. For developers who want transparent, editable, and portable agent memory across multiple coding assistants without cloud dependency, choose Plur. They solve orthogonal problems; the best pick depends on whether your pain point is durability or memory portability.
Plur vs Presto Voice
Plur and Presto Voice serve completely different needs. Plur is a free, open-source toolkit for developers seeking inspectable, cross-agent memory; Presto Voice is an enterprise voice AI platform for QSR drive-thrus. Choose Plur if you code with AI agents and want local memory control; choose Presto Voice if you run a drive-thru chain and need automated ordering with proven upsell ROI. No overlap.
Alternatives to Plur
View all
Vercel
Vercel deploys web apps and AI agents with Git-based CI/CD, global edge delivery, and sandboxed agent infrastructure.
Poolside AI
Open-weight agentic coding models — Laguna XS 2.1 and Laguna S 2.1 — built for secure on-prem and air-gapped enterprise AI.
Frequently Asked Questions
Best-of guides
Used Plur? Help shape our editorial sentiment research.