# AI use cases for Operator Memory (aerovato/operator-memory)

Repo: [aerovato/operator-memory](https://github.com/aerovato/operator-memory) | Use cases: 4 | Page: https://dedupedai.com/use-cases/aerovato-operator-memory/

Operator Memory is a context engine that gives coding agents a Markdown workspace for specs, decisions, standards, and lessons, so each new session starts with what earlier sessions learned.

This file holds every use case of this repo. Each one starts with a "## " heading and ends with its URL.

- Give an existing repo a memory the agent keeps: https://dedupedai.com/use-cases/aerovato-operator-memory/onboard-existing-repo-with-persistent-agent-memory/
- Publish agent-written specs to your team via Git: https://dedupedai.com/use-cases/aerovato-operator-memory/share-project-specs-with-team-through-git/
- Carry your personal agent rules into every project: https://dedupedai.com/use-cases/aerovato-operator-memory/keep-personal-rules-across-all-projects/
- Review and correct what the agent has written: https://dedupedai.com/use-cases/aerovato-operator-memory/audit-and-edit-agent-memory-as-markdown/

## How to give an existing repo a memory the agent keeps with Operator Memory

Repo: [aerovato/operator-memory](https://github.com/aerovato/operator-memory) | Difficulty: Intermediate | Time: 30 minutes | Basis: From the README

Set up Operator on a real project so each new agent session starts from an indexed codebase and written specs.

**Who it is for:** A developer picking up an existing project with a coding agent, who is tired of the agent re-exploring the code at the start of every session.

**The problem:** Agents forget everything when a session ends, so each new session wastes tokens re-learning the architecture and decisions.

**The outcome:** The repo has an Operator brain with an index, and later sessions begin from that knowledge instead of from zero.

### Steps

1. Install the Helper with `npm install --global @aerovato/operator-helper`.
2. Install the adapter for your harness with `operator-helper install claude-code` or `operator-helper install codex`.
3. In a new conversation, run `/operator:user-init` once to set up your global user partition.
4. In your project, start a new conversation and run `/operator:project-init` to scaffold Operator and index the repo.
5. Ask the agent to write the first specifications for the modules you work on, then start a new conversation for normal work.

### Prompt to paste into your agent

```text
Use the Operator Memory repo at https://github.com/aerovato/operator-memory to set up Operator for the project at <project-path>. Run the install steps from its README, then ask the agent to write the first specifications for <module-name>. Verify that a .operator/ directory exists in the project and that it contains at least one specification file.
```

### Caveat

The README says a cold project starts with a sparse brain, so the first sessions will need you to ask the agent for specs before the memory becomes useful.

Disclaimer: Third-party repos we don't own or vouch for. AI-generated use cases can be wrong: review everything and run at your own risk. Full text: https://dedupedai.com/disclaimer/

URL: https://dedupedai.com/use-cases/aerovato-operator-memory/onboard-existing-repo-with-persistent-agent-memory/

## How to publish agent-written specs to your team via Git with Operator Memory

Repo: [aerovato/operator-memory](https://github.com/aerovato/operator-memory) | Difficulty: Intermediate | Time: 30 minutes | Basis: From the README

Promote the specs an agent wrote into the shared folder so teammates receive the same project knowledge.

**Who it is for:** A tech lead or senior developer whose team uses coding agents and needs everyone's agents to work from the same module specs.

**The problem:** Knowledge a single developer's agent learns stays in one local session, so teammates' agents repeat the same investigations.

**The outcome:** Specs live in .operator-shared/, are tracked in Git, and reach teammates through the repository.

### Steps

1. Run `/operator:project-init` in the project if you have not already.
2. Ask the agent to write a spec for a feature before implementing it.
3. Ask the agent to promote that spec to Shared so the team receives it.
4. Commit the .operator-shared/ directory with `git add .operator-shared` and `git commit`. (inferred, check the README)
5. Push the branch so teammates pull the updated shared knowledge. (inferred, check the README)

### Prompt to paste into your agent

```text
Using the Operator Memory repo (https://github.com/aerovato/operator-memory), ask the agent in <project-path> to write a spec for <feature-name> and promote it to Shared. Expected output: a document under .operator-shared/ describing that feature. Verify the file is present and tracked by Git before you push.
```

### Caveat

Shared documents are only as current as the last commit, so teammates' agents see a spec only after it is committed and pulled.

Disclaimer: Third-party repos we don't own or vouch for. AI-generated use cases can be wrong: review everything and run at your own risk. Full text: https://dedupedai.com/disclaimer/

URL: https://dedupedai.com/use-cases/aerovato-operator-memory/share-project-specs-with-team-through-git/

## How to carry your personal agent rules into every project with Operator Memory

Repo: [aerovato/operator-memory](https://github.com/aerovato/operator-memory) | Difficulty: Intermediate | Time: 30 minutes | Basis: From the README

Store your own standards and knowledge in a user partition that applies across all your repos.

**Who it is for:** A developer who works on several projects and wants the same working rules and preferences applied by the agent in each one.

**The problem:** Corrections and standards you teach an agent in one project are lost when you start work in another.

**The outcome:** Your personal rules sit in ~/.operator/user/ and load in each project, so you teach the agent once.

### Steps

1. Install the Helper with `npm install --global @aerovato/operator-helper`.
2. Run `/operator:user-init` once in a new conversation to create your global user partition.
3. Ask the agent to record a standard you want applied everywhere, such as a coding convention you correct often.
4. Open a project, run `/operator:project-init`, and start a new conversation to confirm the rule is consulted.
5. Check the Markdown file in ~/.operator/user/ and edit or delete it if the rule changes.

### Prompt to paste into your agent

```text
Using the Operator Memory repo (https://github.com/aerovato/operator-memory), set up the user partition and record this standard: <standard-text>. Expected output: a Markdown file under ~/.operator/user/ containing that standard. Verify by opening a different project and checking that the agent applies it.
```

### Caveat

The README describes user rules as a separate partition, but it does not say how strictly the agent follows them, so check behavior in a second project.

Disclaimer: Third-party repos we don't own or vouch for. AI-generated use cases can be wrong: review everything and run at your own risk. Full text: https://dedupedai.com/disclaimer/

URL: https://dedupedai.com/use-cases/aerovato-operator-memory/keep-personal-rules-across-all-projects/

## How to review and correct what the agent has written with Operator Memory

Repo: [aerovato/operator-memory](https://github.com/aerovato/operator-memory) | Difficulty: Beginner | Time: 15 minutes | Basis: From the README

Read, update, or delete the Markdown memory files an agent produced to keep the project knowledge accurate.

**Who it is for:** A developer or reviewer who suspects an agent recorded a wrong decision or outdated spec and wants to fix it directly.

**The problem:** Agent-written notes can drift from the real code, and an incorrect note will mislead every future session.

**The outcome:** Each Brain document is checked, corrected, or removed, so the next session starts from accurate knowledge.

### Steps

1. Open the .operator/ and .operator-shared/ folders in your editor after a working session.
2. Read the specs and decisions the agent recorded for the modules you changed.
3. Edit any document that no longer matches the code, or delete one that is wrong.
4. Ask the agent to consolidate two overlapping documents if you see duplicates.
5. Start a new conversation and ask the agent to summarize the module to confirm the corrected knowledge is used.

### Prompt to paste into your agent

```text
Using the Operator Memory repo (https://github.com/aerovato/operator-memory), review the Markdown documents in <project-path>/.operator/ for the module <module-name>. Expected output: a list of documents that conflict with the code, with each one corrected or removed. Verify by starting a new session and checking the agent cites the corrected spec.
```

### Caveat

The README says the brain is updated by the agent during work, but roadmap items such as Reliable Brain Updates are not yet shipped, so you should still review documents by hand.

Disclaimer: Third-party repos we don't own or vouch for. AI-generated use cases can be wrong: review everything and run at your own risk. Full text: https://dedupedai.com/disclaimer/

URL: https://dedupedai.com/use-cases/aerovato-operator-memory/audit-and-edit-agent-memory-as-markdown/