graphwiz.aiThe Best Memory Solution for Agentic Coding with OpenCode
When Microsoft published STATE-Bench in May 2026, the headline was stark: without memory, GPT-5.1 completes fewer than half of enterprise tasks reliably. For coding agents, the number is worse. A coding agent without memory doesn't just forget what you said three hours ago — it forgets the codebase structure, the architectural decisions, the bug you fixed yesterday, and the test you added this morning.
Every major coding tool now ships some form of memory. Claude Code has its file-based system. Cursor uses a vector database. Windsurf auto-captures memory as you work. And OpenCode, being plugin-based, has spawned an entire ecosystem of memory backends. The question is no longer "should you use memory?" but "which memory should you use?"
This article compares the options and recommends the best one for OpenCode users.
How Agentic Coding Tools Handle Memory Today
| Tool | Storage Backend | Retrieval Method | Cross-Session | User Controls |
|---|---|---|---|---|
| Claude Code | Flat files (MEMORY.md, claude.md) | LLM rewrite + 5-stage compaction pipeline | Yes, via file persistence | Edit MEMORY.md directly |
| Cursor | Turbopuffer vector DB + tree-sitter AST | Merkle tree incremental indexing | No | .cursor/rules files |
| Copilot | Local JSON cache in .vscode | Repository-level insight extraction | No | None |
| Windsurf | Cortex auto-analysis engine | Real-time awareness + Memories | Yes, via auto-capture | Memories + notes |
| OpenCode | Plugin-based (5+ backends) | Depends on plugin | Depends on plugin | Depends on plugin |
Claude Code's approach is the simplest: a markdown file that grows until it hits a 25KB index cap, then a compaction pipeline kicks in — Snip, Microcompact, Context Collapse, Autocompact, Resume. It works for small projects but the compaction pipeline is lossy. The LLM decides what to keep, and LLMs are bad at judging what you will need tomorrow.
Cursor and Copilot take the opposite extreme: no cross-session persistence at all. Cursor's .cursor/rules file is a conventions document you edit by hand, not a memory system. Its vector-backed retrieval is impressively fast for in-session code search — Turbopuffer is among the fastest vector databases on the market — but the knowledge dies when the session ends.
Windsurf's Cortex engine does the most for you: it auto-analyses your project, captures context, and builds a persistent "Memories" store. It requires less manual effort than any other tool. But you can't control what it remembers, and you can't inspect the store directly.
OpenCode is different. It defines a standardised MCP memory interface — remember, search, forget — and lets you choose the backend. This means the quality of your memory is entirely determined by which plugin you pick.
The Memory Plugin Ecosystem for OpenCode
| Plugin | Storage | Search | Unique Feature |
|---|---|---|---|
| opencode-agent-memory | Markdown + YAML | Basic keyword | Simplest setup, zero deps |
| opencode-memory (Rust) | SQLite + sqlite-vec | Hybrid (vector + BM25) + association graph | 8 MCP tools, two-tier (global+project) |
| opencode-mem0 | SQLite + usearch | Hybrid | Auto-capture, web UI on :4747 |
| agentmemory (npm) | Multi-store (vector+graph+KV) | Cross-store | 51 tools, 4-tier consolidation pipeline |
| opencode-memsearch | Milvus Lite | Vector + auto-summarisation | Per-project isolation |
The Rust plugin opencode-memory stands out for a simple reason: it is the only plugin that bundles all three retrieval modes — semantic (vector), keyword (BM25), and relational (association graph) — in a single binary. SQLite means zero external services. The two-tier design separates global context (your preferences, conventions, personal patterns) from project context (codebase-specific facts), which maps directly to how coding agents actually work.
Agentmemory has more tools (51 MCP tools against 8) and a sophisticated 4-tier consolidation pipeline, but complexity is a cost. Every consolidation pass can introduce drift, and 51 tools means 51 ways to misconfigure.
Opencode-mem0 offers the friendliest onboarding — install, run, and you get a web dashboard at port 4747 showing what is being stored. The auto-capture feature means you don't need to remember to remember. But the web UI is a separate process to manage, and usearch-based search is generally outperformed by sqlite-vec on recall.
Opencode-memsearch uses Milvus Lite, which is a good vector engine but adds a 400MB dependency. The auto-summarisation is useful for long sessions, but summarisation is just another lossy compression step.
Dedicated Memory Solutions
These aren't OpenCode plugins, but they inform the landscape. Some could be integrated via MCP.
Mem0 (48,000+ stars) offers three-tier memory — user, session, agent — with hybrid vector-graph-KV retrieval. It integrates with 21 frameworks and scores 93.4% on LongMemEval v2. The catch: graph features require the $249 per month Pro tier. The open-source version is essentially vector-only, which means you pay for the architecture that the research says matters most. Mem0 is the right choice if you need multi-tenant memory for a SaaS product and have the budget.
Zep / Graphiti uses a bi-temporal knowledge graph with validity windows — every fact knows when it became true and when it stopped being true. Sub-300ms p95 latency, 63.8% on LongMemEval (independent evaluation), and a 15-point advantage on temporal tasks. If your coding agent needs to answer "what did we decide about authentication last week?" with temporal precision, Zep is unmatched. It is also overkill for most single-project coding setups.
Letta (formerly MemGPT) implements OS-tiered memory: Core (always in context), Archival (searchable), Recall (conversation history). Agents self-manage their own memory via function calls, which is clever but introduces reliability issues — the agent has to correctly decide what to store and retrieve. Letta's 74.0% on LoCoMo with GPT-4o-mini is impressive, but that is filesystem memory, not the agentic tier.
Cognee is the dark horse. It runs a poly-store architecture (graph + vector + relational) with an ECL pipeline, and critically it offers code graph memory — parsing source code into AST-derived entity-relationship triples. For a coding agent, this is the right abstraction: remember the relationship between this function and that type, not just the text. Cognee is local-first and MIT-licensed but requires more configuration than the others.
MemPalace (52,000+ stars) stores verbatim text in ChromaDB using the method of loci, achieving 96.6% recall on LongMemEval with zero API calls. It is local-first and impossible to beat on cost. The limitation for coding agents is that verbatim storage is powerful for conversation recall but weak for structured code knowledge — remembering the exact wording of a chat about authentication is less useful than remembering the entity relationship between the auth controller and the JWT middleware.
Graph vs Vector: What the Research Says
The benchmark data from the companion article (arXiv:2601.01280) is unambiguous. Graph methods outperform flat vector indexes on LongMemEval, and the gap widens as the store grows. For agents operating over long time horizons with many sessions, graph-structured memory consistently beats vector similarity for any retrieval task involving relationships — which is most of what coding agents do.
The AMA-Bench results reinforce this. The AMA-Agent, which uses causality graphs, beats structure-agnostic systems by 24.6% — the largest margin in any recent benchmark. The gap comes from a fundamental property of software work: code decisions form a dependency tree. You cannot understand a commit without knowing the commit that preceded it. Vector search does not model dependencies. Graphs do.
MRAgent (arXiv:2606.06036) adds another dimension: active reconstruction outperforms passive retrieval by up to 23%. Instead of storing facts and hoping the agent finds them, MRAgent actively reconstructs context at inference time. This is computationally heavier but maps well to OpenCode's runtime — an MCP tool that rebuilds relevant context on demand, rather than hoping a vector search surfaces the right document.
The emerging 2026 pattern is hybrid: a vector layer for fast semantic recall, a graph layer for entity and relationship queries, and an episodic buffer for recent session context. No single approach dominates across all dimensions.
The Decision Framework
| Your Situation | Best Option | Why |
|---|---|---|
| Small project, <30 facts | Claude Code's MEMORY.md or opencode-agent-memory | File-based sits on the Pareto frontier for trivial scale |
| Multi-session coding, evolving codebase | opencode-memory (Rust) or Cognee | Hybrid graph+vector handles growth without redesign |
| Temporal reasoning critical | Zep / Graphiti | Bi-temporal validity windows are unmatched |
| Need fastest integration | Mem0 (21 framework adapters) | Plug and play, if you accept the vector-only ceiling |
| Autonomous agent systems | Letta | OS-tiered memory is the right abstraction for self-managing agents |
| Local-first, zero cost | MemPalace or opencode-memory (Rust) | Both MIT, both offline-first |
Recommendation for OpenCode Users
If you use OpenCode and want the best memory for agentic coding today, run opencode-memory (the Rust plugin). Here is why:
It is the only plugin that gives you all three retrieval modes — vector, BM25, and association graph — without external services. The two-tier design (global + project) matches how coding work actually segments. The association graph captures function dependencies, import relationships, and architectural decisions that vector similarity alone would miss. And because it is a single SQLite-backed binary, there is nothing to manage: no Docker container, no cloud bill, no running web server.
For small projects where you want simplicity, the markdown-based opencode-agent-memory is fine. You can edit the memory files by hand, and for projects that fit in one person's working memory, the compaction cost is negligible.
For teams that need multi-user memory with temporal precision, integrate Zep as a secondary store for decision logging and use opencode-memory for the primary context store. The bi-temporal graph is worth the complexity if you have multiple developers relying on the same agent history.
Avoid the trap of assuming more tools equal better memory. Agentmemory's 51 MCP tools sound comprehensive, but each tool is a configuration surface for things to go wrong. Mem0's Pro tier costs $249 a month for the graph features you actually need — and the open-source tier is vector-only, which the benchmarks show is insufficient for complex codebase reasoning.
The best memory is the one your agent actually uses. A modest but reliable hybrid store beats a sophisticated system that adds too much latency or complexity. Opencode-memory (Rust) clears that bar.
What's Next
The field is moving toward active memory reconstruction — systems that rebuild context at inference time instead of searching static stores. OpenCode's plugin architecture means a plugin implementing MRAgent's approach (arXiv:2606.06036) could ship without any core changes. The pieces are all there: the MCP interface, the tool system, the session model. Someone just needs to write the runtime.
For now, the choice is clear. File-based for trivial projects, MemPalace for verbatim conversation history, Zep for temporal precision, and opencode-memory for everything else. The Rust plugin is the best answer to the question that STATE-Bench exposed: how do you build a coding agent that actually remembers?