A practical export-and-reimport exercise for checking whether agent memories preserve text, scope, corrections, and identity.
2026-11-16 · Data
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
An evergreen trial for agent memory: verify that a one-task instruction does not silently replace a durable user preference.
2026-11-13 · Data
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
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
A practical, vendor-neutral exercise for distinguishing useful memory search results from an exhaustive list of remembered facts.
2026-11-10 · Data
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
Evaluate autonomous agent memory with concrete tests for persistence, scope, corrections, recall, deletion, and failure handling.
2026-11-07 · Data
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
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
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
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
A focused acceptance exercise for uncertain memory writes: interrupt the response, inspect stored state, and verify retries before trusting recovery.
2026-11-02 · Data
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
A practical diagnostic worksheet to separate missing writes, wrong scopes, retrieval misses, and incorrect use of remembered decisions.
2026-11-01 · Data
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
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
Debug missing cross-session context by tracing a fact from save acknowledgement to storage, retrieval, and the next agent action.
2026-10-29 · Data
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
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
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
A practical handoff template and restart test for carrying decisions, corrections, and unfinished work into an agent's next session.
2026-10-25 · Data
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
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
A practical evaluation checklist for temporary facts: define validity, inspect retrieval, test abstention, and distinguish retirement from deletion.
2026-10-22 · Data
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
An evergreen evaluation checklist: change one remembered rule, then verify that unrelated preferences survive across fresh agent sessions.
2026-10-20 · Data
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
Trace a forgotten correction from storage to retrieval to use, then test whether it survives a fresh agent session.
2026-10-18 · Data
Test saving, scope, retrieval, and actual use separately to diagnose why an AI agent loses project context after a restart.
2026-10-17 · Data
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
A practical exercise for evaluating memory retries, duplicate records, and corrections without confusing transport safety with semantic deduplication.
2026-10-15 · Data
A practical, vendor-neutral exercise for checking whether delayed memory writes can undo an approved correction across agent sessions.
2026-10-14 · Data
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
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
A practical checklist for evaluating memory-tool failures: distinguish empty recall from errors, check uncertain writes, and rehearse recovery.
2026-10-11 · Data
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
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
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
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
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
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
Test whether agent context is saved, retrieved, and applied across sessions with a small, inspectable memory handoff checklist.
2026-10-04 · Data
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
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
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
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
A controlled restart drill for long-term agent memory: separate remembered facts from prompt clues, task files, and lucky guesses.
2026-09-29 · Data
Debug cross-session forgetting by separating saved, queued, delivered, retrieved, and used memory—with a practical PLUR outbox example.
2026-09-28 · Data
Test persistence, recall, correction, scope, and failure handling before choosing a long-term memory tool for your AI agent.
2026-09-27 · Data
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
A practical workflow for preserving coding decisions, checking what a new session can retrieve, and storing scoped corrections with PLUR.
2026-09-25 · Data
A practical guide to keeping organizational knowledge useful and under your control when AI agents learn from your work.
2026-09-24 · Data
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
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 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 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
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
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
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
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
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
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
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
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
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
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
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
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
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
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 (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
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
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, 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
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
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
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
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
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
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
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
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