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.
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.