Operator Memory plugin
Memory for coding agents in plain Markdown: the agent keeps specs, decisions and lessons itself, and each new session starts from them. No vector database
- 476 ★ on the repository
- Last commit
- BSD-3-Clause
Extended access
Why this level
- The agent automatically creates and edits Markdown documents in the project and the home folder
- Memory is added to the agent's system prompt, and shared-folder documents go into the repository and to colleagues
Install
- Works in
In your terminal, with SkillFoxx CLI
npx skillfoxx add plugins/operator-memoryDetects the agents on your machine, shows the access level and pins the version.
Other ways to install
Access and checks
How we reviewExtended accessThe tool runs code or makes network calls and only reads external data.
- The agent automatically creates and edits Markdown documents in the project and the home folder
- Memory is added to the agent's system prompt, and shared-folder documents go into the repository and to colleagues
This is third-party code. Review the repository files before installing.
What it does
Operator Memory gives a coding agent a working knowledge store about the project, called the Brain. During normal work the agent writes specs, decisions, standards, research and lessons into it, and the next session starts from that knowledge instead of spending tokens re-exploring the code and architecture. Knowledge lives in Markdown that you can read, edit and delete by hand. The store splits into three places. The `.operator/` folder in the project holds private knowledge and stays on your machine. The `.operator-shared/` folder is published with the repository, and the whole team receives its documents through Git. The `~/.operator/user/` directory keeps your personal rules for all projects. Each session repeats one loop: the agent consults the Brain, does the task, then updates the canonical files with no RAG database of records in the scheme. Installation goes through the `operator-helper` program, and then for your agent with `operator-helper install claude-code`. The commands `/operator:user-init`, `/operator:project-init`, `/operator:index` and `/operator:repair` work in the chat. Claude Code, Codex, OpenCode, Pi, DeepSeek Harness and Kiro are supported. There are no background agents, embeddings or vector database.
Who it is for. For developers and teams who work with agents on long-lived code and want every session to remember the previous ones' decisions.
Good fit when
- The agent re-learns the project architecture in every new session and burns tokens on it
- You need to write a feature spec before implementation and keep it current as work goes on
- A team needs to share project knowledge through Git: decisions and research live in `.operator-shared/`
- You want to keep your own rules and preferences apart and apply them across projects: `~/.operator/user/`
- You need memory you can open, read and fix by hand
Not a fit when
- You need to remember conversation snippets with semantic search: Operator keeps documents and uses no embedding search
- The project is throwaway and knowledge will not outlive one session
- Your agent is not on the list: Claude Code, Codex, OpenCode, Pi, DeepSeek Harness, Kiro
- Project documents must not go into the repository: the shared part is published with it, though the private part can stay local
Example request
Write a spec for this feature before implementing it, and record this research so we do not repeat the investigationLimitations
The project is under active development, and the author promises more features, each with its own switch. Claude Code needs version 2.1.287 or newer and Node.js 20 or newer. Support for OpenCode V1 and Kiro is marked as supported with caveats, while the other agents are called fully supported. On a cold start in an existing project the memory will be sparse, and you have to ask the agent to write the first specs for the modules you need. The agent sometimes hesitates to create, merge or split documents and needs steering. Memory is added to the system prompt once per Claude Code process. Installation goes through npm, and adapter updates use the same command.
How to disable. For Claude Code disable or remove the `operator@operator-memory` plugin with `/plugin`. The `.operator/`, `.operator-shared/` and `~/.operator/` folders stay, so delete them if you do not need the knowledge.
FAQ
How do I install Operator Memory for Claude Code?
Install the helper with `npm install --global @aerovato/operator-helper`, then run `operator-helper install claude-code`. It registers the aerovato/operator-memory marketplace and installs the `operator@operator-memory` plugin. Check `claude plugin list`, then start a new Claude Code process.
What do /operator:user-init and /operator:project-init do?
The first sets up your personal knowledge partition once, and the second creates the Operator structure in each new project, migrates existing documents and indexes the repository. They are explicitly invoked skills and should be run in a new chat.
How is this different from RAG memory plugins?
There are no embeddings, vector database or background agents. Knowledge lives in plain Markdown documents, and when a fact about the project changes, the agent edits the right file. The author put the comparison with other plugins in docs/comparison.md.
How do I share knowledge with the team?
Put documents in `.operator-shared/`: the folder is published with the repository and reaches colleagues through Git. The request "Promote this spec to Shared" moves a spec from the private area to the shared one.
Which agents does Operator Memory work with?
Claude Code (CLI and Desktop), Codex (CLI and Desktop), OpenCode V2, Pi and DeepSeek Harness are fully supported. OpenCode V1 is marked as legacy support and Kiro as supported. Each has its own variant of the `operator-helper install` command.
Discussion
No questions or reviews yet.
Related
PluginsLong-term memory for AI agents: Markdown files as the source of truth, a SQLite index as a cache, shared by Claude Code, Codex and others
Long-term agent memory in local Markdown files with a link graph, semantic search and MCP access
A portable .agent folder with memory, skills and protocols that plugs into many coding agents and keeps its knowledge when you switch tools
Local persistent memory for coding agents: hooks record every session, and Claude Code, Codex or Cursor recall past decisions through 54 MCP tools
Long-term memory for agents: it distills knowledge from session history and brings it back in new tasks, one store shared across Claude Code, Codex, Cursor and
Knowledge-graph memory for agents: Claude Code and Codex plugins, an MCP server and a Python library
Comparison with similar tools
Entries that share the main search query, and how they differ.
| Entry | Official | Authentication | Repository stars | Main difference |
|---|---|---|---|---|
| Operator Memory (this entry) | no | 476 | ||
| Basic Memory | no | not required | 4,323 | long-term agent memory in local Markdown files with a link graph and semantic search, as an MCP server |
| mex | no | 1,777 | shared team memory in the repository synced through Git, but as a console utility |
README in short
The README lays out the idea: agents are good within one session but forget everything when it ends, and Operator gives them a durable Markdown workspace. Installing the helper through npm or Bun follows, with a table of agents and commands. It then covers the three-step setup, the consult, build, update loop, everyday prompts for the agent and the roadmap. It ends with links to the comparison with other memory plugins, a guide, architecture and troubleshooting.