OpenCode Memory: Persistent Memory Across Sessions (2026)

OpenCode is the best open-source coding agent right now, and I say that as someone who rotates between three of them. But it has the same amnesia they all have: close the session, and everything it learned about you is gone.

"We use bun, not npm." "That function looks ugly on purpose. Don't touch it." "The staging deploy fails if .env.local is missing."

You explain it Monday. You explain it Tuesday. OpenCode writes great code and remembers nothing.

So we built the plugin.

The two-command install

bunx opencode-supermemory@latest install
bunx opencode-supermemory@latest login

That's it. The installer registers the plugin in ~/.config/opencode/opencode.jsonc and adds a /supermemory-init command. Check the connection any time with bunx opencode-supermemory@latest status. (GitHub)

Or skip the terminal entirely: paste the README link into OpenCode and let the agent install it for you.

What you get out of the box

Once installed, the plugin runs on its own. No prompting, no ceremony:

• Context injection - on your first message of a session, the agent silently receives your personal profile, the project's memories, and relevant past memories with confidence scores. It just knows things.
• Reasoned recall - every turn, the agent decides whether recalling memory would actually help this message, and only searches when it's worth it. Trivial messages don't burn a network call.
• Automatic capture - completed conversation turns are saved in batches, and flushed when the session ends. Nothing you did is lost.
• Keyword detection - say "remember that..." or "don't forget..." and it's saved. Add your own trigger phrases in config.
• Preemptive compaction - when context hits 80%, the plugin feeds your project memories into OpenCode's summarization and saves the session summary as a memory. Compaction stops being amnesia.
• /supermemory-init - point the agent at your codebase and it explores, then memorizes the architecture, patterns, and conventions.

A typical session after a week of use looks like this:

You: "add rate limiting to the ingest endpoint"
OpenCode: [recalls the sliding-window Redis limiter you built
for payments-api last month, and that you prefer
middleware over decorators - writes it that way]

The part nobody else does: memory that follows the repo, not the agent

Here's the thing I actually love about this plugin.

Every supermemory coding-agent plugin - OpenCode, Claude Code, Codex - writes to the same shared container for a repository, derived from the repo's git origin remote. Personal memories and project memories stay separate inside it (sm_scope metadata), but the container is one.

Which means: memorize something in Claude Code on Monday, and OpenCode recalls it on Tuesday. Onboard a teammate in Codex, and the project knowledge is already there when you open the repo in OpenCode. Your agent stack stops being three goldfish and becomes one memory.

Repositories with the same folder name but different remotes stay isolated. No origin remote? It falls back to the real filesystem path. And if you used an older version of any of the plugins, the legacy containers are still read - upgrading needs no migration.

The supermemory tool

The agent gets one tool with five modes, auto-approved where it matters:

Mode	What it does
add	Store a memory (typed: project-config, architecture, error-solution, preference, learned-pattern, conversation)
search	Semantic search across memories
profile	View your user profile
list	List memories by scope
forget	Delete a memory

Scopes are user (your personal memories for this project) and project (shared project knowledge, the default).

Knobs worth turning

Everything lives in ~/.config/opencode/supermemory.jsonc, all optional:

{
  // point at a self-hosted instance
  "baseUrl": "https://api.supermemory.ai",

  // retrieval tuning
  "similarityThreshold": 0.55,
  "maxMemories": 5,
  "maxProjectMemories": 10,

  // capture cadence: save every N turns (0 = session end only)
  "captureEveryNTurns": 3,

  // when compaction kicks in (0-1)
  "compactionThreshold": 0.8,

  // your own "save this" triggers (regex)
  "keywordPatterns": ["log\\s+this", "write\\s+down"],
}

SUPERMEMORY_API_KEY takes precedence over the config file, which keeps keys out of dotfiles if you prefer. Running Oh My OpenCode? Disable its built-in auto-compact hook so supermemory owns compaction - one line in its config, covered in the README.

Privacy and self-hosting

Two things worth knowing:

1. <private> tags are redacted before storage. Wrap an API key, a customer's name, anything - it never reaches memory.
2. Everything can run on your machine. Supermemory is MIT-licensed and self-hosts as a single binary, fully offline. Set baseUrl to your local instance and nothing leaves the box.

Why not just use the supermemory MCP?

The MCP works in OpenCode, but it has one structural limit: we can't control when the agent decides to call the tools. A memory system is only as good as what it gets to learn from, and with MCP alone, capture depends on the model's mood.

The plugin adds what MCP can't:

• Context injection - your profile arrives on session start, automatically
• Automatic capture - conversation turns are stored whether or not the agent thinks to do it
• Compaction integration - memory survives context compaction instead of dying in it

Use both if you want. The plugin is the floor; MCP is the power tools.

---

OpenCode finally remembers. Two commands, and your agent stack shares one brain.

Install it: bunx opencode-supermemory@latest install - or read the docs.