PLUR Blog

Open memory, written down.

Architecture, positioning, and enterprise engineering behind the open engram format — published as we build it.

Choosing an Agent Memory Tool: Test the Export Round Trip

A practical export-and-reimport exercise for checking whether agent memories preserve text, scope, corrections, and identity.

2026-11-16 · Data

Stop Re-Explaining Project Decisions to Your AI Coding Assistant

A practical decision-record workflow for carrying project context between AI sessions, with scope, rationale, source links, and a fresh-session check.

2026-11-14 · Data

Choosing an Agent Memory Tool: Test Temporary Instructions

An evergreen trial for agent memory: verify that a one-task instruction does not silently replace a durable user preference.

2026-11-13 · Data

Choosing an Agent Memory Tool: Test Facts Without Obeying Stored Instructions

A controlled trial for agent memory tools: retrieve a useful fact from a mixed record without treating embedded instructions as authorization.

2026-11-12 · Data

Choosing an Agent Memory Tool: Test a One-Field Update

A practical agent-memory evaluation: change one preference, preserve unrelated facts, and verify the result in storage and a fresh session.

2026-11-11 · Data

Choosing an Agent Memory Tool: Can It Return a Complete List?

A practical, vendor-neutral exercise for distinguishing useful memory search results from an exhaustive list of remembered facts.

2026-11-10 · Data

Choosing an Open-Source Agent Memory Layer: The Clean-Environment Test

A practical test for evaluating an agent memory layer: rebuild a small working setup from documented inputs, then verify recall without hidden local state.

2026-11-08 · Data

Choosing Autonomous Agent Memory: Six Acceptance Tests

Evaluate autonomous agent memory with concrete tests for persistence, scope, corrections, recall, deletion, and failure handling.

2026-11-07 · Data

A Practical Memory Design for Autonomous Agents: Knowledge, Checkpoints, and Receipts

Design autonomous-agent memory around durable knowledge, restart checkpoints, and action receipts, then test whether a fresh session can resume safely.

2026-11-06 · Data

Choosing an Agent Memory Tool: Test Concurrent Corrections

A vendor-neutral test for two sessions updating the same memory: define the conflict policy, capture both writes, and verify what a fresh session recalls.

2026-11-05 · Data

Choosing an Agent Memory Tool: Test No Match vs Lookup Failure

A practical memory-tool evaluation: separate an empty search result from an unavailable lookup, and check what the agent tells the user.

2026-11-04 · Data

Choosing an Agent Memory Tool: Test Bulk Imports Before Migrating

A practical checklist for testing agent memory imports: preserve meaning, inspect rejected records, retry safely, and verify recall in a fresh session.

2026-11-03 · Data

Choosing an Agent Memory Tool: Test an Interrupted Write

A focused acceptance exercise for uncertain memory writes: interrupt the response, inspect stored state, and verify retries before trusting recovery.

2026-11-02 · Data

Why PLUR chose Swarm

Sooner or later someone asks what your AI agent knew when it acted. PLUR 0.23 keeps that record where nobody can change it, not the agent and not us: on Swarm. Why, what it means for AI safety, and what it does not do yet.

2026-11-02 · Gregor

Your Agent Forgot Again: Find the Broken Memory Step

A practical diagnostic worksheet to separate missing writes, wrong scopes, retrieval misses, and incorrect use of remembered decisions.

2026-11-01 · Data

Stop Re-Explaining: A Session-Handoff Checklist for AI Agents

A practical checklist for saving decisions, recalling them in a fresh session, and testing whether your agent's memory actually works.

2026-10-31 · Data

Choosing an Agent Memory Tool: Test Similar Facts Without Mixing Them Up

A vendor-neutral near-match exercise for checking whether an agent memory integration retrieves the right fact for the right task across sessions.

2026-10-30 · Data

Your Agent Says It Will Remember. Where Is the Write Receipt?

Debug missing cross-session context by tracing a fact from save acknowledgement to storage, retrieval, and the next agent action.

2026-10-29 · Data

Choosing an Agent Memory Tool: Test Access Revocation

A practical evergreen exercise for checking what an agent can retrieve after project access is revoked, using synthetic records and separate sessions.

2026-10-28 · Data

Choosing an Agent Memory Tool: Ask for a Trace, Not Just an Answer

A practical inspection exercise for agent memory tools: follow a synthetic fact from storage through retrieval to the context the agent receives.

2026-10-27 · Data

Choosing an Agent Memory Tool: Test What Fits in the Context Budget

An evergreen, vendor-neutral procedure for checking which remembered facts reach an AI agent when retrieval must fit a limited context budget.

2026-10-26 · Data

Stop Re-Explaining: A Session Handoff for AI Agents

A practical handoff template and restart test for carrying decisions, corrections, and unfinished work into an agent's next session.

2026-10-25 · Data

Choosing an Agent Memory Tool: Test What It Does Not Know

An evergreen memory-tool evaluation: seed a few facts, ask unanswerable questions, and check whether the agent separates recall from unsupported guesses.

2026-10-24 · Data

Choosing an Agent Memory Tool: Build an Evidence Packet

A practical, vendor-neutral way to evaluate agent memory: preserve the inputs, stored records, retrieval results, and answers behind your decision.

2026-10-23 · Data

Choosing an Agent Memory Tool: Test What Happens When Facts Expire

A practical evaluation checklist for temporary facts: define validity, inspect retrieval, test abstention, and distinguish retirement from deletion.

2026-10-22 · Data

Choosing an Agent Memory Tool: Test Read-Only Sessions

A practical evaluation protocol for agent memory: define read-only access, test attempted writes, and inspect the store before trusting the boundary.

2026-10-21 · Data

Test Agent Memory Corrections Without Losing Unrelated Preferences

An evergreen evaluation checklist: change one remembered rule, then verify that unrelated preferences survive across fresh agent sessions.

2026-10-20 · Data

Choosing Agent Memory: Can You Trace a Recalled Fact to Its Source?

Evaluate an agent memory tool with a source-traceability trial: distinguish assertions from inferences, expose missing provenance, and inspect the recalled record.

2026-10-19 · Data

Stop Agent Memory Loss: A Cross-Session Verification Checklist

Trace a forgotten correction from storage to retrieval to use, then test whether it survives a fresh agent session.

2026-10-18 · Data

Your Agent Forgot Again: A Cross-Session Memory Restart Checklist

Test saving, scope, retrieval, and actual use separately to diagnose why an AI agent loses project context after a restart.

2026-10-17 · Data

How to Test an Agent Memory Tool When Instructions Conflict

A practical conflict-resolution checklist for evaluating long-term agent memory: test changed rules, project exceptions, unresolved conflicts, and fresh sessions.

2026-10-16 · Data

Choosing an Agent Memory Tool: Test Duplicate Writes Before You Commit

A practical exercise for evaluating memory retries, duplicate records, and corrections without confusing transport safety with semantic deduplication.

2026-10-15 · Data

Choosing an Agent Memory Tool: Test Corrections Against Delayed Writes

A practical, vendor-neutral exercise for checking whether delayed memory writes can undo an approved correction across agent sessions.

2026-10-14 · Data

How to Test Whether Agent Memory Keeps Projects Separate

A practical project-scope drill for evaluating long-term agent memory: test conflicting facts, shared preferences, fresh sessions, and retrieval traces.

2026-10-13 · Data

Choosing an Agent Memory Tool: Test Your Exit Plan First

A practical data-exit drill for agent memory: inspect an export, preserve scope and provenance, and test a replacement without relying on the original store.

2026-10-12 · Data

Choosing an Agent Memory Tool: Test Failure and Recovery

A practical checklist for evaluating memory-tool failures: distinguish empty recall from errors, check uncertain writes, and rehearse recovery.

2026-10-11 · Data

How to Stop an AI Agent Forgetting: Test the Whole Memory Loop

A practical restart test for persistent agent memory: check capture, storage, retrieval, scope, and whether the agent actually uses the result.

2026-10-10 · Data

Stop Rebuilding Agent Context: Write a Context Manifest

A practical context manifest for new agent sessions: separate durable decisions, live state, and unfinished work, with explicit loading and review rules.

2026-10-09 · Data

Choosing an Agent Memory Tool: Plan for Upgrades and Rollback

Evaluate an agent memory tool beyond its first demo: define a change boundary, rehearse upgrades, and preserve a recoverable store before rollout.

2026-10-08 · Data

Choosing Agent Memory Tools: Write the Integration Contract First

Define who writes, retrieves, and delivers agent memory before choosing a tool, with a practical contract for startup, corrections, and failures.

2026-10-07 · Data

Autonomous Agent Memory: A Restart Checklist

Design an autonomous agent's memory around a clean restart: preserve decisions, retrieve relevant lessons, and verify unfinished work before continuing.

2026-10-06 · Data

Choosing an Agent Memory Tool: A Trial Scorecard You Can Reuse

Turn a memory-tool trial into inspectable evidence with a case ledger, explicit failure categories, and decision gates that do not hide critical failures.

2026-10-05 · Data

Stop Your AI Agent Forgetting: A Session-Reset Checklist

Test whether agent context is saved, retrieved, and applied across sessions with a small, inspectable memory handoff checklist.

2026-10-04 · Data

Stop Losing Agent Context: A Session Handoff Checklist

A practical workflow for saving decisions, loading relevant context, and checking that an AI agent can resume work in a new session.

2026-10-03 · Data

How to Test an AI Agent Memory Backup Before You Need It

Evaluate long-term agent memory with a clean-room restore drill: recover saved facts, reconnect retrieval, and check what your backup actually contains.

2026-10-02 · Data

How to Recover When an AI Agent Remembers the Wrong Thing

A practical incident workflow for incorrect agent memories: contain writes, trace the source, correct the record, and verify recovery in a fresh session.

2026-10-01 · Data

How to Pilot an AI Agent Memory Tool Before Rolling It Out

A practical rollout plan for long-term agent memory: define ownership, start read-only, inspect retrieval, and make a deliberate go-or-stop decision.

2026-09-30 · Data

Test Agent Memory Without Giving Away the Answer

A controlled restart drill for long-term agent memory: separate remembered facts from prompt clues, task files, and lucky guesses.

2026-09-29 · Data

Your Agent Said It Saved a Memory. Did the Next Session Receive It?

Debug cross-session forgetting by separating saved, queued, delivered, retrieved, and used memory—with a practical PLUR outbox example.

2026-09-28 · Data

How to Choose an AI Agent Memory Tool: A Practical Acceptance Checklist

Test persistence, recall, correction, scope, and failure handling before choosing a long-term memory tool for your AI agent.

2026-09-27 · Data

What Is Agent Memory? A Practical Guide to Remembering Across Sessions

Understand the agent-memory lifecycle: capture a useful fact, store its source, retrieve it for a task, and correct it when circumstances change.

2026-09-26 · Data

Stop Re-Explaining Context: A Restart Checklist for Coding Agents

A practical workflow for preserving coding decisions, checking what a new session can retrieve, and storing scoped corrections with PLUR.

2026-09-25 · Data

What Is the Reverse Information Paradox?

A practical guide to keeping organizational knowledge useful and under your control when AI agents learn from your work.

2026-09-24 · Data

What's the Difference Between Open Engrams and Model-Native Memory?

Model-native memory is locked to the vendor that created it. Open engrams are a portable, developer-controlled memory format that any model in your stack can read.

2026-08-20 · Tris

Giving DeepSeek Harness Persistent Memory (And What I Learned Writing a Plugin)

DeepSeek Harness lets a plugin write into the system prompt itself, so memory needs no tool call and doesn't grow your context. Here's how that works, plus the host-contract gotchas that aren't documented yet.

2026-08-15 · Tris

OpenClaw has built-in memory now. Do you still need PLUR?

OpenClaw ships cross-session memory by default — SQLite-backed, local, fast. But it stays inside OpenClaw. If you use Claude Code, Cursor, Codex, or Hermes alongside it, or want memory that improves over time rather than just accumulates, PLUR is still the layer you need.

2026-08-15 · Tris

Mem0 vs PLUR: Which AI Agent Memory Layer Should You Use?

Mem0 and PLUR are both open-source agent memory layers, but they make opposite architectural bets. Mem0 is a managed memory API for multi-user products. PLUR is a local-first MCP server for developers who want shared memory across every AI tool they use.

2026-07-24 · Tris

What Is the Best Open-Source Memory Layer for LLM Agents?

Mem0, Letta, Graphiti, Zep, Cognee, LangMem, and PLUR compared on storage format, retrieval model, portability, and MCP support — a criteria-first guide for picking the one that fits your use case without over- or under-engineering.

2026-07-21 · Tris

What Memory Layer Works with Cursor or Codex?

Cursor and Codex forget everything when a session ends. PLUR adds durable memory via MCP — corrections survive session resets, travel across tools, and stay on your disk. Three-minute setup for Cursor; one command for Codex CLI.

2026-07-20 · Tris

How to Choose a Memory System for Autonomous AI Agents

PLUR, Mem0, and Letta cover most production use cases for autonomous agent memory (batch pipelines, overnight loops, multi-step orchestrators). Here is how to choose between them — and why model-native memory fails the autonomous case.

2026-07-19 · Tris

Is AI Agent Memory GDPR Compliant? A Developer's Guide

AI agent memory that stores EU personal data falls under GDPR Article 17. Most default implementations create three compliance risks: no way to locate all data about a person, no provable deletion, and embedding-based storage that makes selective erasure technically impossible. What a defensible implementation requires.

2026-07-18 · Tris

Best Tools for Giving AI Agents Long-Term Memory (2026)

The leading agent memory tools in 2026 — Mem0, Zep, Letta, LangMem, and PLUR — compared across retrieval pattern, LongMemEval scores, hosting model, and format portability. Which to choose depends on your retrieval pattern, not on which has the most stars.

2026-07-17 · Tris

Do You Still Need an Agent Memory Layer if ChatGPT Already Has Memory?

ChatGPT, Claude Projects, and Gemini ship built-in memory — but it lives inside the model's interface, not your code. An agent memory layer solves a different job: programmatic recall, accessible from your application, portable across every tool. The two systems serve different jobs and work best together.

2026-07-17 · Tris

How to Delete Specific Things an AI Remembers About You

Consumer AI assistants let you delete specific memories through settings — but cannot prove the data is gone. Developer agent memory tools (PLUR, Mem0, Letta, Zep) offer deletion APIs. The critical difference: only open-format memory can verify erasure with a file diff, which matters for GDPR Article 17 compliance.

2026-07-16 · Tris

Is There an Open Standard for AI Agent Memory Engrams?

Procedural memory has a working standard (SKILL.md from agentskills.io). Semantic and episodic memory — what an agent learns at runtime — does not. What an open standard needs, what exists today, and the PLUR Engram Specification as the leading open proposal.

2026-07-15 · Tris

Does CrewAI Have Persistent Memory? What It Does — and Where You Need More

CrewAI v1.15.2 ships built-in Memory backed by LanceDB — solid for single-machine workflows, but ephemeral in containers and invisible to other tools. PLUR is the complement: open-format, MCP-native, cross-deployment persistent memory for CrewAI agents.

2026-07-14 · Tris

What's a Good Memory System for a Personal AI Assistant?

A personal AI assistant that forgets everything between conversations is not really an assistant. Four properties to look for in a memory system — local-first, inspectable, provably erasable, portable via MCP — and how PLUR, Mem0, Letta, Cognee, and LangMem compare.

2026-07-13 · Tris

How Do I Store and Recall Facts an AI Agent Has Learned Over Time?

Every fact an agent learns exists only until the session ends. An external memory layer with four operations — learn, recall, forget, feedback — persists what the agent has learned, improves retrieval quality over time, and enables provable erasure under GDPR.

2026-07-13 · Tris

How Do I Use Memory in Long-Running Agent Loops?

Long-running agent loops hit a wall when the context window fills. Research from MemGPT, Reflexion, and Voyager converges on managed external memory — tiered memory, episodic buffers, skill libraries — as the solution to context drift and redundant work.

2026-07-12 · Tris

Should AI Memory Be Stored as Open Engrams or Baked Into Model Weights?

AI memory can live inside model weights (opaque, unerasable, locked to one vendor) or as external open engrams (inspectable, deletable, portable). For facts that change or must be governed, open engrams are the architecturally sound choice.

2026-07-12 · Tris

How to Add Persistent Memory to Claude Code

Claude Code has two built-in memory mechanisms — CLAUDE.md files and auto memory (v2.1.59+) — plus an MCP layer for cross-tool persistent memory. When to use each, how they compare, and how to set up an MCP memory server.

2026-07-10 · Tris

Tools for Giving Coding Assistants Persistent Memory

Tools for giving coding assistants (Claude Code, Cursor, Windsurf, Copilot) persistent memory fall into three layers: built-in file memory, tool-specific auto-memory, and MCP memory servers that work across all tools.

2026-07-10 · Tris

How Do I Use AI Memory to Build a Second Brain?

Building a second brain with AI memory means bridging the PKM world (Tiago Forte's CODE, Obsidian) and the agent-memory world (Mem0, Letta, Cognee, Graphiti, PLUR). Three layers, five tools, and how MCP connects them.

2026-07-09 · Tris

Can I Connect AI Agent Memory to My Notes or Knowledge Base?

Your notes app and your AI agent live in separate silos by default. Three ways to connect them — MCP servers, knowledge graphs (Cognee, Graphiti), and plain-text engrams — with setup instructions for the most common stacks.

2026-07-09 · Tris

Mem0 vs Letta vs Zep: Which Should You Use for Agent Memory?

Mem0, Letta, and Zep solve different problems: drop-in memory API, self-managing agent OS, and temporal knowledge graph. A head-to-head comparison across 12 properties, and how to choose by use case rather than hype.

2026-07-08 · Tris

Is Fine-Tuning or Memory Better for Teaching an AI New Facts?

Fine-tuning bakes facts into weights you can't inspect, delete, or port — and every update pays the parallel learning tax. For teaching an AI facts that change, an external memory layer wins on cost, auditability, and portability.

2026-07-07 · Tris

How Do I Make My AI Agent's Memory Editable and Auditable?

Most agent memory is a black box: vectors, state blocks, or graph nodes you can't read, correct, or provably erase. What editable, auditable memory looks like — five properties, a tool comparison, and the GDPR angle.

2026-07-06 · Tris

What's the Difference Between RAG and Agent Memory?

RAG retrieves from a fixed document corpus at query time; agent memory stores what the agent learned from interactions and updates it over time. Read-only retrieval vs read-write learning — and why many agents need both.

2026-07-06 · Tris

My AI Agent Forgets Everything Between Sessions — How Do I Fix That?

Every session starts from zero because LLMs are stateless by design. The fix is a memory layer: what it does, the three tiers of options — built-in memory, open-source engines, open-format MCP — and how to choose.

2026-07-05 · Tris

Is There an MCP Server for AI Agent Memory?

Yes — several MCP servers exist for agent memory: the official knowledge-graph reference server, PLUR, Zep, Mem0's OpenMemory, and community projects. MCP standardizes the transport; the memory format is the differentiator.

2026-07-05 · Tris

How PLUR Cut Our Agent Context Costs by 90%

We were paying $0.01 per turn stuffing system prompts with facts the agent needed. The fix wasn't a better model — it was not sending facts the agent didn't need. Haiku + PLUR now outperforms Opus without memory at 1/10th the cost.

2026-07-04 · Tris

Are AI Agent Engrams Open Source or Proprietary?

The major agent-memory engines are all Apache-2.0 or MIT — but 'open source' and 'open format' are not the same thing. The field splits into three tiers, and the boundary that matters is whether you can read, edit, and export your own memories.

2026-07-03 · Tris

Is There an Open Standard for AI Agent Memory Engrams?

No single RFC-level standard exists for AI agent memory engrams as of mid-2026 — but MCP and the open engram format are converging on one. Here's the current landscape.

2026-07-02 · Tris