Public Artifacts
Shareable demos and launch writeups
These are the public Memnode artifacts designed to be linked from demos, launch posts, GitHub, and MCP listings. They focus on one thing: making the memory wedge legible fast.
Stop Putting Agent Memory in the Context Window (2026)
The context window is a bounded, volatile, flat buffer - not a memory. Why agent memory belongs in a durable external layer, the four kinds it must hold (working, semantic, procedural, episodic), and why an inspectable record-recall-lineage-correction loop beats a black-box retriever.
Agent Memory Frameworks in 2026: Letta, Mem0, Graphiti, Cognee - and Where a Durable, Inspectable Layer Fits
The honest landscape builders share to decide what to adopt. Letta (ex-MemGPT), Mem0, Graphiti/Zep, and Cognee compared fairly, the local-first wave including Mnemosyne, the land grab with no breakout, and why a durable inspectable layer sits beneath the frameworks rather than competing as another one.
How Memnode Evolved: From a Graph Database to a Memory Reasoning Engine
The honest engineering story of how memnode grew from a file-backed graph and embeddings store into a memory reasoning engine, reconstructed from internal design docs: nine stages of inspiration, critique, and self-imposed discipline.
Episodic and Semantic Memory: The Two-Layer Model Behind Durable Agent Recall
Why a flat vector index fails agents, and how memnode separates episodic memory (what happened) from semantic memory (distilled facts), letting experience consolidate into evidence-backed knowledge over time.
Spreading Activation: Why Graph-Aware Recall Beats Top-K Similarity
Top-k vector similarity is the wrong default for agent recall: similarity is not relevance and it cannot follow the chain of facts a task needs. Spreading activation over a typed memory graph fixes under-recall without over-recall.
Canonization: How a Memory System Decides What It Believes
A naive store treats every recorded fact as equally true forever. memnode gives each memory a status that changes over its lifecycle: provisional, supported, canonical, disputed, deprecated, quarantined. How evidence drives promotion and demotion, and why it makes agent memory accountable.
Belief Networks for Agents: Holding Contradictions Instead of Overwriting Them
Most agent memory resolves conflicts by overwriting or silent top-k ranking, so an agent asserts a claim its own memory contradicts. memnode models support and rebuttal edges, scores tension, and recalls disagreement instead of faking consensus.
Sleep for Machines: Offline Consolidation in an Agent Memory Engine
Recall and writes happen on the hot path, but a memory engine needs a slow clock too. How offline consolidation promotes episodes to facts, merges duplicates, decays salience, surfaces contradictions, and strategically forgets so recall quality holds up as the store grows.
The Trust Hierarchy: Epistemic Types and Source Trust in Agent Memory
Not all agent memories deserve equal weight. How memnode tags each memory with an epistemic type (observed, reported, inferred, hypothesized) and a source trust signal, and how those feed canonization, recall ranking, and duty-class memory.
Measure or Do Not Ship: The Evaluation Gate Behind a Memory Engine
A memory engine is a machine for being confidently wrong. This is how memnode adopted one rule, no new memory behavior ships unless it is measured against a baseline, and why that turned a pile of clever heuristics into a system you can trust.
LangGraph Checkpointer vs Store: Why Your Agent Forgets Across Threads
Wire up a LangGraph checkpointer, see state survive a conversation, assume it is memory, then watch the agent forget the user the next day. The checkpointer is thread-scoped short-term state; the store is cross-thread long-term memory. The precise distinction, the real API for both, and where a store stops being enough.
Compaction Is Not Memory: What Your Agent Forgets When the Window Fills
Context compaction feels like the agent kept everything and got efficient. It did not. The new compact_20260112 API drops the raw turns and keeps a lossy summary. Why compaction amnesia and context rot are the same mistake, and the clean split between window management and durable memory.
Memory Poisoning: The Agent Attack That Survives a Restart (OWASP ASI06)
Prompt injection ends when the chat closes. Memory poisoning persists across sessions and fires days later. OWASP made it ASI06 in 2026, and its core defense is provenance-tracked memory, exactly what an auditable memory layer provides.
Why Your AI Memory Layer Recalls the Wrong Thing (mem0, Zep, Letta, and the 64% Ceiling)
The memory-layer category exploded in 2026, but the same complaint follows every product: it remembers the wrong thing. The anatomy of four memory jobs, the LongMemEval recall ceiling (Zep 63.8% vs Mem0 49.0%), the three ways recall fails, and the structural fix.
An MCP Memory Server Isn't Enough: Tool Access Is Not Recall Quality
Against our own interest: handing an agent an MCP memory server solves access, not recall quality. What MCP genuinely fixes, the three things it leaves to the backend (provenance, supersession, recency), the Letta self-managed-memory counterpoint, and what "enough" actually looks like.
Add Persistent Memory to Claude Code with MCP: A Step-by-Step Guide (2026)
Claude Code forgets everything between sessions, and CLAUDE.md is static docs you maintain by hand. Wire up real record / recall / lineage memory through MCP in four steps — plus the usual reasons "Claude Code memory not working" and how to fix them.
How to Give Your AI Agent Long-Term Memory (2026): The Practical Guide
The four shapes of agent memory — conversation buffer, vector retrieval, structured key-value, and knowledge graph plus MCP — when each fits, and the five properties that actually decide a memory system. A practical default for 2026.
Pinecone Migration Playbook 2026: 12 Lessons From Teams That Already Moved
Pinecone's May 2026 knowledge-graph pivot caught teams mid-migration. Here are 12 patterns from real Pinecone → alternative migrations: cost shocks, the embedding-recompute trap, hybrid index sync, and the cleanest path to agent memory.
Cloudflare Agent Memory Beta: Teardown, Limits, and When Self-Hosted Wins
Cloudflare's Agents SDK ships a memory primitive in beta. We tested what it stores, what it doesn't, the per-tenant limits, the cold-start tax, and the three use cases where self-hosted memory still wins.
n8n AI Agent Memory: The Three Shapes That Work (And One That Doesn't)
Window Buffer, Postgres Chat on Supabase, or graph-backed memory: a decision map for which n8n memory backend fits which agent shape. Costs, failure modes, and the one option that quietly loses data in production.
Agent Memory Benchmarks 2026: The Real Numbers (LongMemEval, LOCOMO, and the Gaps)
OMEGA at 95.4% LongMemEval. Mastra at 94.87%. Mem0 at 66.9% LOCOMO. The scores are real but the benchmarks measure different tasks. Here is what each one actually tests, what they miss (cost, lineage, poisoning), and how to pick a memory system in May 2026.
Mem0 Plugin for AI Editors vs Memnode: Which One Should Hold Your Agent Memory
Mem0 shipped a Claude Code / Cursor / Codex plugin in March 2026 with auto-capture lifecycle hooks. Honest comparison against memnode: when cloud-backed cross-tool memory wins, when local namespace-scoped memory wins, and the case for running both.
Four Hermes-Inspired Memory Features, Synthesized From a Graph
NousResearch Hermes describes four useful agent-memory primitives (session brief, procedural outcomes, end-of-session consolidation, FTS recall) and stores them in flat files. We re-implemented them against memnode's knowledge graph. The change is small in code and large in operational consequence: less plumbing per feature, dedup and lineage become free, and EMA-graded procedures self-correct without a separate analytics pipeline.
Persistent Memory for AI Live-Ops Agents on Game Backends
Live-ops agents that watch multiplayer game backends need persistent memory to stop reinventing the same playbook every session. The two-tier pattern: backend as system of record, memnode as the inspectable memory layer.
Vector embeddings are the wrong default for AI agent memory
Three concrete failure modes from production agents that drove me to stop reaching for a vector DB first: drift hallucinations, awkward writes, and using 1536-dim floats to index 200 bytes of state. When structured KV plus MCP memory servers actually fits, and when vector DBs do.
MCP Memory Servers Compared: Memnode, Mem0, Zep, Cognee
A practical comparison of the four MCP-compatible agent memory servers worth evaluating in 2026. Trust models, fit, and a quick decision matrix.
Lineage and Provenance in Agent Memory: Why Inspectable Beats Magical
Most agent memory systems treat memories as opaque blobs. Provenance and correction chains turn the loop inside out so you can audit, correct, and explain agent behavior.
Garbage Collection Strategies for Agent Memory Stores
Agent memory grows. TTL, LRU, and typed eviction each fit different shapes. Why typed eviction beats simpler strategies for memory you actually want to keep long-term.
Hosted vs Local Agent Memory: When Each Fits
Local memory wins on privacy and latency for dev tooling. Hosted memory wins on multi-device and team scale for production agents. The decision tree and the costs people underestimate.
Memory Patterns for Multi-Agent Systems
Three shapes of shared memory in multi-agent systems (isolated, fully shared, scoped shared) and the orchestrator pattern that prevents the race conditions and memory poisoning that come with shared writes.
Claude Code Memory Demo: Record, Recall, Show Lineage
A public Memnode demo artifact that shows the exact loop a developer can run today: install MCP, teach one repo convention, recall it later, and inspect the lineage.
Flowise Memory Nodes: The Decision Map (Buffer Window, Redis, Zep, and the Agentflow Trap)
Flowise ships ten memory nodes and one slot. Which backend fits which agent: Buffer Window (persistent, not what the name implies), Redis for multi-instance, summary nodes for long chats, Zep for facts. Plus the two bugs behind most Flowise amnesia: chatflow memory in Agentflows, and the missing sessionId.
CrewAI Memory: Four Stores Behind One Flag (and the Three Walls You Hit in Production)
memory=True turns on ChromaDB short-term + entity memory, SQLite long-term learnings, and contextual assembly. Where each store lives on disk, why containers wipe it (CREWAI_STORAGE_DIR), the recency/semantic scoring knobs, and the three production walls: no user scoping, no shared memory, no lineage.
OpenAI Agents SDK Sessions: Persistent, Until You Need Actual Memory
SQLiteSession, the SQLAlchemy backend, and the compaction wrapper: which session fits which deployment, what Runner.run(session=...) automates, and the four things a message log cannot do (extract facts, cross sessions, scope per user, explain a recall). The two-layer pattern production agents converge on.