How to choose memory for your coding agents

There are now many ways to give a coding agent memory, from a notes file in your repository to hosted memory services with their own benchmarks. This isn’t a scorecard of every product. It’s a way to think about the choice.

We make Assertion, so we have a view. We’ll say where it fits and where something else fits better.

What should you compare?

Six criteria come up in almost every comparison, and all of them are worth checking.

Accuracy. Almost every memory product publishes a benchmark score. To compare two, make sure they use the same benchmark, answer model and judge: LoCoMo, LongMemEval and BEAM test different things, and a stricter judge alone can move a score by 15 points. Ours is in the benchmark report: on BEAM 100K, with the same answer model and judge, Assertion scored 81.1% and Hindsight 77.9%.

Token size and cost. Every memory recalled is text sent to the model, so you pay for it on every turn, and the right memory does more than more memory. Ask how much a tool sends per question. In the same benchmark run, Assertion sent 12.2k tokens per question and Hindsight 17.7k.

Open source or not. Open source often comes down to keeping memory inside your own environment. Many companies would rather the vendor install and support it on-premise than run the database, model keys, upgrades and backups themselves. Either way, ask where it can run, who runs it there, and what leaves your environment. Hindsight, Supermemory, mem0, Basic Memory and Letta are open source. Assertion runs in our cloud, or we deploy it in yours.

How memory gets captured. You write it (CLAUDE.md, rule files), your code sends it (memory APIs, which remember what your code submits), the agent decides to save it, or it’s captured from the work automatically. Hand-written memory is precise, API-fed memory gives full control when you’re building your own agent, and automatic capture keeps up without anyone having to do anything.

Speed. Recall adds a step before the agent answers. Few vendors publish recall latency, so ask for numbers on your own workload and try it in a real session.

Data security. Ask what’s stored (transcripts, source code, or something distilled from them), where, for how long, and whether there’s a SOC 2 report today, and for which plans. Our SOC 2 Type II audit is in progress.

What else should you look at?

What the memory understands.

The six criteria tell you how well a tool keeps and finds information. For a team, one more question matters: does the memory understand what you’re trying to do?

How do we see memory?

As strategy. We call it strategic memory.

From facts to strategy

Most memory tools, including the ones built into coding agents, keep notes, facts or documents and find the ones closest to the request. Some add structure, like a graph of entities or a tree of topics. That’s a solid foundation. Strategic memory adds the layer above it: what you’re trying to achieve, the questions that raises, and what’s been decided and why.

What strategic memory keeps

Strategic memory is organized the way a team actually works through a problem:

• Goals: what you’re trying to achieve.
• Key questions: what has to be figured out to get there.
• Answers: the decision for each question, the reasons, and the options ruled out.
• How it was done: the steps, conventions and evidence behind each answer.

It’s captured automatically as you work. Nobody writes it up. And it keeps this, not your transcripts or source code.

What makes it different

• It knows where the project is going. A good leader expects a team member to understand the big picture, not just the task in front of them. Strategic memory gives your agent that. It starts from your goals, not from the latest fact, so a new session, or a new teammate’s agent, already knows what the project is trying to achieve and where it’s heading. It’s often the first thing teams notice: their agent understands the direction, not just the details.
• It can tell a detail from a change of direction. A good leader also expects a team member not to be thrown by details: to adjust when something small changes, and to step back when something big does. Strategic memory knows whether new information belongs to a low-level question or a high-level goal. A tweak to one setting updates one answer and leaves the plan alone. A new requirement that touches a goal reopens the questions under it.
• It asks the questions. Strategic memory brings question-asking into memory itself. It organizes a developer’s thinking into the questions that matter and their current answers, the way a good tech lead keeps track of a project. That compresses far more than a list of notes: weeks of sessions become a handful of goals and questions, so the agent gets more understanding from fewer tokens.

Built for teams

Strategic memory is most useful when several people, and several agents, work toward the same goals.

• Everyone starts from the same picture. Each teammate’s agent, in Claude Code, Cursor or Codex, starts from the team’s goals, open questions and decisions, not from whatever that one person happened to tell it.
• Clear boundaries. Memory is private to you until you share a space. Share a space with your team, or with a contractor on one project, and only that space is shared.

How should you choose by situation?

Start from your situation, not from a feature list.

Built-in memory

For one developer, in one tool, happy to write the rules by hand. CLAUDE.md, AGENTS.md and Cursor rules are free and need nothing installed. Claude Code’s auto memory and Codex’s Memories add notes the agent saves for itself, but they stay on your machine, so teammates’ agents don’t learn from each other. Keep an instructions file either way. It’s the right home for rules.

Memory APIs

For building your own agent or AI app. If you’re writing the agent, you want a memory layer you call from code: your code decides what to send it and when to ask it for something back. Zep, mem0, Letta, Supermemory and Hindsight all offer one. They’re building blocks, not something you add to Claude Code. Assertion isn’t a memory API.

Memory plugins

For adding memory to the coding agent you already use. A plugin captures your sessions and brings back what’s relevant in later ones, with no files to maintain. mem0, Supermemory, Hindsight, ByteRover and Basic Memory work this way, and several are open source.

Assertion covers this: plugins for Claude Code, Cursor and Codex, with strategic memory and team spaces. Free for individual developers, including at work. Teams pay $10 per member a month ($8 annually), with a 14-day trial. Install it here.

Memory-native agents

For an agent built around memory from the start, not as an add-on. Instead of carrying the whole conversation and compacting it when it fills up, a memory-native agent keeps a small prompt and brings back from memory what each step needs. Letta Code is one example.

Assertion covers this too: the Assertion agent is our own coding agent for Mac, with the same strategic memory built in. Memory is part of the app, so switching collaboration spaces or viewing what’s been saved takes one tap. Long sessions don’t compact, it uses 3× or more fewer tokens on long sessions because memory decides what each prompt needs, and it runs Claude, GPT, Gemini, Grok and Muse on one bill. One Team seat covers both the agent and the plugins, so a team can mix them.

So which should you choose?

• You work alone and like control: start with what’s built in.
• You’re building your own agent: a memory API.
• You want memory to fill itself in, and you want to run it yourself: an open-source memory plugin.
• Memory has to stay inside your environment, but you don’t want to run it: a vendor that will deploy and support it there.
• Your team works toward shared goals over weeks and months, and you want every agent to know what’s decided, what’s open and why: strategic memory. Try Assertion free on a real project, in the plugin or the agent, before bringing the team in.

Questions people ask

What is strategic memory?

Memory organized around what a team is trying to achieve. It keeps the goals, the key questions under each goal, and the decisions that answer them with their reasons. So it knows where the project is going, can tell a detail from a change of direction, and turns weeks of work into a handful of goals and questions.

Does Claude Code have memory?

Yes. CLAUDE.md files hold instructions you write, and auto memory saves notes Claude decides are worth keeping. Auto memory stays on your machine and isn’t shared with teammates.

What’s the difference between CLAUDE.md and a memory tool?

CLAUDE.md is a file someone writes and keeps current. A memory tool fills itself in from your work. Most teams use both: CLAUDE.md for rules, memory for everything learned along the way.

Plugin or memory-native agent?

A plugin keeps the agent you already have and adds memory to it. A memory-native agent goes further, because memory is part of the agent itself: you can switch collaboration spaces or see what’s been saved in one tap. It also keeps cost down by using memory to decide what goes into each prompt, sending the model only what the step needs instead of the whole conversation. With Assertion, both share the same memory, so a team can mix them.

Do we need open source to run memory on-premise?

No. Open source lets you install and run it yourself. If you’d rather the vendor install and support it in your environment, ask for that directly. Either way, check what leaves your environment and whether you can export your memory.

Which memory scores highest on benchmarks?

Compare published scores only when the benchmark, answer model and judge match. On BEAM 100K with all three fixed, Assertion scored 81.1% and Hindsight 77.9%.

Last checked November 5, 2026. Assertion gives Claude Code, Cursor and Codex strategic memory that writes itself as your team works. It is free to start: install it here.