Tool Highlight: Atlaso — One MCP Memory That Follows You Across Claude Code, Cursor, and Codex
A memory layer that connects over MCP so every coding agent you use recalls the same projects, decisions, and preferences. Free to start — but you're routing your working context through one brand-new vendor.
4 min
Memmy vs Memorix vs MemSearch vs memhub: Giving Every Coding Agent the Same Memory
You run Claude Code, Codex, and Cursor on the same repo — and each one starts from zero. Four open-source tools fix that by sharing memory across agents. They disagree on one thing that decides which you want: who controls what gets remembered.
6 min
Mem0 vs Zep vs Letta, August 2026: The Self-Host Question Just Changed
Six weeks ago you could run all three agent-memory layers on your own hardware. You can't anymore — Zep deprecated its self-hostable Community Edition, so the choice is now as much about where the code runs as how it remembers.
6 min
What a 1M-Token Context Actually Costs to Self-Host: The DeepSeek-V4-Flash Memory Math
DeepSeek open-weighted a million-token, MIT-licensed model on July 31. Before you 'just self-host it,' here's the number nobody puts on the launch slide: the memory floor. The context window is the cheap part.
4 min
Migrate a Bedrock Agents Classic Agent to AgentCore: The Runtime, Gateway, and Memory Calls That Actually Replace It
There's no converter button. Classic ran your config; AgentCore runs your code. Here's the concrete port map — reuse the Lambdas and Knowledge Base, rewrite the orchestration — with the verified CLI and SDK calls, ARM64 gotcha included.
6 min
Claude's Memory Tool vs Memory Stores: Two Things Named 'Memory' That Solve Opposite Problems
Anthropic ships two agent-memory primitives with nearly identical names. One is an interface you back yourself; the other is managed, versioned state you rent. The deciding question isn't which remembers better — it's who runs your agent loop and who should own the bytes.
5 min
Memorix vs memsearch vs agentmemory vs Memmy: Picking a Cross-Agent Memory Layer
Four open-source tools now give Claude Code, Codex, and Cursor one shared memory. They don't disagree on recall — they disagree on what your agent's memory *is*: files you own, a tool your agents call, a local service, or a second-brain agent.
6 min
Agent Memory in Three Tiers — Short, Persistent, Long — and How to Wire Each One
Every 'give your agent memory' course collapses three different problems into one word. They aren't the same problem, and they don't use the same code. Here are the three tiers, the one call that wires each, and the rule for when a fact should climb from one tier to the next.
6 min
Why Agent Memory Rots in Production: The Four Failure Modes (and the Fix for Each)
Wiring the three memory layers is the easy part. Keeping them healthy over weeks of real traffic is where agents fall over. Here are the four ways memory rots — unbounded growth, stale retrieval, no forgetting, and poisoning — and the specific fix for each.
5 min
Short, Persistent, and Long: The Three Kinds of Agent Memory (and When Each Is the Wrong One)
Working memory, session memory, and long-term memory solve three different problems. Most agents that 'forget' are using the wrong one — or paying for all three when they needed one. A founder's decision guide, with the tools mapped.
5 min
How to Build a Swappable Agent Memory Layer: One remember() / recall() Over sqlite-vec, LanceDB, and Qdrant
The store you pick today is the store you'll outgrow. Put a two-method interface in front of it now, and moving from a file to a service becomes a migration you run in an afternoon — not a rewrite you dread.
7 min
VitaBench 2.0: The Best Agents Score ~50% at Remembering You — and Bolting On Memory Makes It Worse
Meituan's new benchmark tests whether an agent can learn a user across days and weeks of fragmented chats. The strongest model manages about a coin flip with the whole history in context — and the moment you swap that for a real memory layer, agentic or RAG, the score drops. If you sell a 'remembers you' feature, read this before you ship it.
5 min
The Three Kinds of Agent Memory: Working, Session, and Long-Term — a Builder's Map
Every agent-memory tutorial names a different set of things "memory." There are only two axes underneath, and once you can see them the vendor menu stops being confusing.
7 min
How to Wire Claude's Memory Tool Into Your Agent: A Copy-Paste Walkthrough
The memory tool is now GA on the Messages API — no beta header. But it ships no database: Claude only *asks* to read and write files, and your code does the work. Here's the whole loop, plus the one line of validation that keeps it from reading your secrets.
5 min
Full Context vs a Memory Layer: The 35-Point Accuracy Gap Nobody Puts on the Slide
A memory layer cuts your tokens and latency by an order of magnitude. On the benchmarks that sell it, a plain full context still answers harder questions more correctly — by tens of points. Both are true, and the gap is the decision.
5 min
vLLM 0.26 and SGLang 0.5.16 Shipped the Same Day. This Time They Fought Over Memory.
Two weeks ago the inference-engine fight was the scheduler sync stall. Both engines cut new releases on July 25, and the headline work moved down a layer — to where your KV cache lives when it no longer fits in VRAM. Two philosophies, one problem.
4 min
LongMemEval-V2 Moves the Memory Benchmark From Chat Logs to Agent Trajectories — and Starts Timing You
The benchmark that defined agent-memory scores just shipped a V2. It swaps chat histories for 115M-token web-agent trajectories and adds query latency as a scored axis — so 'stuff more context' stops being a free win.
4 min
Nvidia's $500B SK Deal Locks Up HBM4 Memory: What the Squeeze Means for Everyone Renting GPUs
The real bottleneck in AI compute was never the chip — it's the high-bandwidth memory stacked next to it. Nvidia just pre-committed a huge slice of SK hynix's HBM4 output, and the marginal GPU a small team rents gets tighter from here.
3 min
How to Wire Context Editing and the Memory Tool Together in the Claude API
The decision piece told you they're a division of labor. This is the code: one request that clears stale tool results in the window and writes durable facts outside it — plus the four config lines that keep it from thrashing your prompt cache.
5 min
How to Combine Context Editing, Compaction, Memory, and Subagents in One Claude Agent SDK Loop
Anthropic ships four levers for keeping a long-running agent inside its window. The comparison pieces tell you which is which — this one wires all four together in one loop, in code.
5 min
The Three Kinds of Agent Memory, Implemented: Working, Session, and Long-Term
By the end you can wire all three memory tiers into a real agent — trim the live context, checkpoint state across a turn with a LangGraph checkpointer, and store durable facts in a vector table — with runnable Python for each.
6 min
Stateful vs Stateless MCP: What You Actually Give Up When You Delete the Session
The 2026-07-28 spec makes MCP stateless by default. That is the right call for most servers — but 'stateless protocol' does not mean 'stateless system.' Here is where your state really goes.
3 min
How to Build a Production Memory-Tool Handler for Claude (Path-Traversal Guards Included)
The memory tool ships no storage — the reference handler exists to be replaced. Here is a complete Python one, backed by a per-user directory, with the six commands, the exact return strings the model expects, and the security that the demo stores skip.
8 min
Where Should the Claude Memory Tool's Files Live? Local Disk vs Object Storage vs a Database
The memory tool hands you a filesystem the model drives and lets you decide what a path means. That decision — disk, S3, or database rows — sets your per-user isolation, your durability, and whether you can survive a redeploy. Here's how to pick.
4 min
Platform Memory vs Your Own Store: Where Should Your Agent's Memory Live?
A founder decision the China persona law just forced — the case for renting the memory layer, the case for owning it, and the one line that settles it for a team of one.
4 min
How to Give Your Users Exportable Agent Memory (Before a Regulator Deletes It for You)
A code-first walkthrough — model agent memory as provider-neutral JSON, ship /memory/export and /memory/import, and satisfy GDPR Article 20 and China's persona law with the same endpoint.
4 min
The Founder's Wire, Week of July 23: Google Makes Memory a Process, Alibaba Ships an Agent-Native Cloud, and Kimi K3's Open Weights Land in Days
Four verified moves that change what a team of one ships this week — Google's always-on memory agent that drops vector databases entirely, Alibaba's agent-native cloud stack from WAIC, Kimi K3's 2.8-trillion-parameter open weights landing July 27, and the MCP stateless spec now days from its July 28 lock.
5 min
Tool Highlight: Statewave — Agent Memory You Can Replay, Prove, and Delete
Most memory layers retrieve fresh guesses at query time, so the same question can hand your agent different context twice in a row. Statewave compiles memory once and hands back a signed, reproducible bundle — same subject, same moment, same bytes — with a receipt for every fact it used.
4 min
Statewave vs Mem0 vs Zep: Which Agent-Memory Bet Survives an Audit
Three open-source memory layers, three different answers to one question a regulator, a customer, or your own incident review will eventually ask: what did the agent know, and can you prove it? Mem0 optimizes recall, Zep optimizes change-over-time, Statewave optimizes proof.
6 min
Provable Deletion Just Became the Axis Agent-Memory Vendors Compete On
China's persona law went live July 15; GDPR already demanded erasure. Together they make 'prove your agent forgot' a requirement — and memory tooling is now competing on auditability, not recall.
5 min
How to Give Your Letta Agent a Sleep-Time 'Dream' Subagent
Enable one flag and Letta spins up a background agent that reworks your primary agent's memory off the critical path — better recall, zero added user-facing latency.
6 min
Inside Mem0 2.x: The ADD-Only Engine That Dropped the Graph Store
Mem0's 2.x line rewrote how an agent's memory is written and read — one LLM call per turn, no UPDATE/DELETE, and entity links built into the main store so you no longer bolt on a graph database. Here's how the new add-and-retrieve path works, with the exact API.
6 min
How to Run a Private, Local Memory Server for Your Coding Agent with OpenMemory MCP
Give Cursor, Claude Desktop, Cline, and Windsurf one shared, on-machine memory over MCP — no cloud, no vendor lock, in about ten minutes.
5 min
How to Add Persistent Memory to Your Agent with Mem0: A Copy-Paste Quickstart
Four methods — add, search, get_all, delete — turn a stateless agent into one that remembers a user across sessions. Here's the working code, the self-host-vs-managed choice, and the one setting that decides your bill.
4 min
Tool Highlight: Mem0 — Drop-In Persistent Memory for Your AI Agent
Your agent forgets everything the moment the request ends. Mem0 is the memory layer you add in two calls — it extracts what matters from a conversation, stores it, and hands the right facts back on the next turn, per user.
3 min
Make Your Agent's Memory Portable: Export, Own, and Re-Import With mem0
A code-forward walkthrough for getting every memory out as structured JSON you control — add, get_all, re-import — so no vendor's shutdown can delete your users' context.
5 min
Mem0 Cut Retrieval Tokens ~90% by Giving Up Write-Time Reconciliation — Here's the Trade
Mem0's token-efficient rewrite stops doing UPDATE and DELETE when it stores a memory, and pushes the hard part — reconciling contradictions — to read time. That's not a free win. It's a bet about where you can afford to spend.
4 min
The Largest Forced Deletion of Agent Memory in History Has No Export Button
China switches off Doubao and Qwen's AI companions on July 15. The overlooked lesson isn't the category ban — it's that hundreds of millions of accumulated personas can't be moved anywhere.
4 min
Tool Highlight: AgentPrizm — Governed Memory and Skills for Your Agents
A hosted memory-plus-skills layer for MCP agents that promises audit receipts and right-to-forget; free to start, but you're renting your agents' memory.
4 min
MemoryArena vs LoCoMo: Why Agent Memory Scores 95% on the Benchmark and ~50% When It Has to Act
The agent-memory leaderboard is fought on LoCoMo, a passive-recall test. MemoryArena couples memory to action — and the same near-perfect systems fall 40 points. The gap isn't inflation; it's the wrong exam.
5 min
The Claude Memory Tool Ships No Storage — It's a Contract You Implement
Anthropic's memory tool gives Claude a /memories directory it can read and write across sessions. But the directory is a fiction, the store is your code, and so is every line of the security.
5 min
Cognee vs Graphiti vs Mem0: How Much Schema Your Agent's Memory Commits at Write Time
The axis that actually separates the open-source memory engines isn't graph vs vector — it's how much structure each one commits when it stores a fact, and that quietly decides which questions your agent can answer later.
5 min
Agent Memory Poisoning: Why OWASP's ASI06 Is Prompt Injection That Never Resets
Prompt injection dies when the context window clears. Memory poisoning writes the payload into the store the agent trusts — so it fires in every future session, with the attacker long gone.
4 min
Memora vs Wiki Memory: Two Bets on What Agent Memory Should Be
Microsoft and LangChain shipped agent-memory frameworks a day apart in June. They disagree on the one axis the benchmarks don't measure — whether you should be able to read what your agent remembers.
4 min
When Agent Memories Contradict: Don't Let the LLM Decide Which One Is Fresh
Your agent stores the same fact twice with different values. The intuitive fix — ask the model which is newer — is the one 2026's benchmarks say to avoid.
4 min
Agent File (.af): Can You Actually Move a Stateful Agent Between Frameworks?
Letta's .af format serializes an agent's memory, tools, and history into one JSON file. The pitch is portability. What it delivers best is something quieter — a savefile — and that distinction decides whether it's useful to you.
5 min
Redis Agent Memory Server: Two-Tier Memory as Infrastructure, Not a Library
Mem0, Letta, and Zep argue about how to structure an agent's memory. Redis's answer is quieter and more radical: make memory a server, and move the expensive part off your agent's request path.
5 min
Mem0 vs Zep vs Letta: Why Agent-Memory Benchmarks Don't Agree
The whole agent-memory leaderboard war — 84% vs 58% vs 75% — is being fought over a ten-conversation dataset called LOCOMO. Once you see how the numbers are made, you stop shopping on accuracy.
4 min
LangMem vs Mem0: Memory You Program vs Memory You Call
They get compared like rivals, but one is memory you program and the other is memory you call — and the benchmark leaderboard only measures one of them.
4 min
Google Open-Sourced an Agent Memory System With No Vector Database. Read the Design.
A Google PM's 'Always On Memory Agent' stores everything in SQLite and consolidates it with an LLM every 30 minutes. The 30-minute number tells you exactly what it's for — and what it isn't.
5 min
What Anthropic's 'Dreaming' Does to Agent Memory — and Why a Bad Dream Doesn't Wash Out
Claude's new consolidation loop replays an agent's day and writes down what it learned. The same mechanism that lifted one customer's task completion ~6x is the one that makes a poisoned lesson permanent.
6 min
TeleMem vs Mem0: When a Drop-In Memory Layer Is Really a Different Bet
TeleMem ships as a one-line replacement for Mem0 — import telemem as mem0 — and claims a 16-point accuracy edge. Read where that number comes from and you learn exactly which agent it's for.
4 min
How AI Agents Decide What to Forget: Memory Consolidation in Mem0, Zep, and the Memory Tool
Every serious agent-memory system is really a forgetting system. The hard part was never storing what the agent learns — it's pruning the contradictions and stale facts that quietly poison retrieval.
5 min
How Many Tokens Does an Agent Memory Layer Use? From 7K to 3.26M per Query
A June 2026 paper clocks three popular memory frameworks on the same benchmark: 118K, 632K, and 3.26M tokens per query. The 500x spread isn't noise — it's a design choice most teams never realize they're making.
5 min
Agent Memory Benchmarks: LoCoMo vs LongMemEval vs BEAM
The benchmarks that grade an agent's memory just moved the finish line from 9,000 tokens to 10 million — and the new one proves a million-token context window doesn't buy you long-term memory.
4 min
How to Read an Agent-Memory Benchmark: The LoCoMo and LongMemEval Number Wars
Mem0 says 92.5% on LoCoMo. Mastra says 95% on LongMemEval. Zep corrected its own 84% to 58%. They can't all be right — and the baseline that beats them all is the one no vendor charts.
5 min
How to Evaluate AI Agent Memory: LoCoMo, LongMemEval, and Why Long Context Isn't Enough
Bigger context windows don't fix forgetting. The benchmarks that actually test agent memory — LoCoMo and LongMemEval — and what their question categories reveal about where it breaks.
4 min
Stateful vs Stateless AI Agents: Where the State Actually Lives
"Stateless" is a misnomer. The state never disappears — it relocates to the client and gets replayed, in full, on every single turn. The real question is who stores it and who pays to replay it.
4 min
The Four Kinds of Agent Memory: Working, Episodic, Semantic, Procedural
Most teams buy one vector store and call it 'memory.' It solves exactly one of the four problems — which is why the agent still loses the thread and repeats yesterday's mistake.
5 min
Mem0 vs Zep vs Letta: Choosing a Memory Layer for Your AI Agent
Three popular open-source memory frameworks that look like rivals but are actually three different bets on where memory lives — and how much of your architecture you hand over.
5 minLatest in Agent Memory
Not buyer's guides — the news, teardowns, and explainers behind this topic.
Why the Top Agent-Memory System on LongMemEval Stores Everything Verbatim — and Runs No LLM
MemPalace tops the long-term memory benchmark by refusing to summarize. That's not a trick — it's an argument that the field spent two years solving the wrong half of the problem.
5 min
Three Places to Keep an Agent's Memory
The memory libraries aren't competing on accuracy. They're competing on geography — where the remembering happens relative to your agent's loop. Pick the place, not the benchmark.
4 min
Memory Stopped Being a Layer
The hard problem of agent memory was never remembering. It's knowing when a remembered fact has quietly stopped being true.
5 min
Agent Memory and State
Nine repositories tackling the hardest unsolved problem in agent design — remembering, retrieving, and forgetting across the lifetime of a conversation.
4 min
Everyone Ships Agents. Almost No One Ships Memory.
The industry has standardized how agents reach out to the world and ignored the harder question of what they keep — and that asymmetry is not an accident.
5 min