> ## Documentation Index
> Fetch the complete documentation index at: https://docs.orchestrahq.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# Bring your existing memory

> Read the memory you already keep in Claude Code, AGENTS.md, Cursor and other tools, so your first session with Orchestra already knows it

You do not have to start over. If your agents already keep memory in other
tools, Orchestra can read it, with your permission, tool by tool. Your tools
keep working exactly as before: Orchestra only reads, and never writes into
their files.

## When you run orchestra enable

`orchestra enable` offers the memory this repository already has: its
`CLAUDE.md`, `AGENTS.md` and `GEMINI.md` files (and other rules files in it),
and Claude Code auto memory for this repository. It lists them once, on one
line, with how many memories each holds, and asks one question for all of
them. Memory from your other projects, and your own files for every repo, is
counted on one line and not read:

```text theme={null}
Memory you already keep for this repo
  CLAUDE.md (56 memories), AGENTS.md (90 memories), Claude Code auto memory (29 memories).
  21 other projects (not read). orchestra enable --local --all-projects offers them.
Read these into your memory and keep them in sync, import once, or skip? [c/o/S] c
Connected 3 sources, 175 memories read.
```

To be asked about every tool and project found on this machine, one question
per tool, run `orchestra enable --local --all-projects`, or
`orchestra sources connect` at any time.

Nothing is read before you answer. Run without a terminal (in a script or by an
agent), it lists what it found, reads nothing, and tells you to run
`orchestra sources connect`. Orchestra's own capture of your sessions keeps
running either way. If one place cannot be read, the others are still read, and
the one that failed is named with the reason. Everything below works the same
any time later.

## See what is on your machine

```bash theme={null}
orchestra sources
```

This lists every supported source it finds, with how many memories each holds
and when it last changed. Nothing is read or sent until you say yes.

## Choose what Orchestra reads

```bash theme={null}
orchestra sources connect
```

For each tool you choose one of three things (a tool with memory in several
places, such as Claude Code auto memory for several projects, is one
question):

| Choice | What happens |
| - | - |
| **Connect** | Orchestra reads it now and keeps it in step as it changes |
| **Import once** | Orchestra reads it now, once |
| **Skip** (default) | Nothing is read |

When it is done you see how many memories were read, from which tools, and
one example with where it came from. To connect without being asked, name the
tools: `orchestra sources connect cursor --yes`.

## What it reads

| Tool | Files | Who sees it |
| - | - | - |
| Claude Code | `CLAUDE.md` at every level of the repository, `.claude/rules/` | Your team |
| Claude Code | `~/.claude/CLAUDE.md`, `~/.claude/rules/`, `CLAUDE.local.md` | Only you |
| Claude Code auto memory | `MEMORY.md` and its topic files under `~/.claude/projects/` | Only you |
| AGENTS.md | `AGENTS.md` at every level of the repository | Your team |
| Codex | `~/.codex/AGENTS.md` | Only you |
| Gemini CLI | `GEMINI.md` in the repository, `~/.gemini/GEMINI.md` | Your team, or only you |
| Cursor | `.cursor/rules/*.mdc` | Your team |
| Windsurf (Devin Desktop) | `.devin/rules/`, `.windsurf/rules/`, `.windsurfrules`, `~/.devin/rules/` | Your team, or only you |
| GitHub Copilot | `.github/copilot-instructions.md`, `.github/instructions/` | Your team |
| Cline | `.clinerules/`, `~/Documents/Cline/Rules` | Your team, or only you |
| Kiro | `.kiro/steering/`, `~/.kiro/steering/` | Your team, or only you |
| Aider | `CONVENTIONS.md` | Your team |
| claude-mem | Its observations and session summaries, through its local worker (or a private read-only copy of its database when the worker is not running) | Only you |
| agentmemory | Its memories and its semantic and procedural memories, through its local API | Only you |
| Codex memory | With Codex memory on: the notes Codex keeps when you ask it to remember something, its memory summary, `MEMORY.md` and its skills, under `~/.codex/memories` or `~/.codex/memories_v2` (or your `CODEX_HOME`) | Only you |

Files checked into a repository are shared with your workspace, like the
repository's sessions. Files in your home folder, auto memory,
`CLAUDE.local.md`, claude-mem, agentmemory and Codex memory are personal: only
you can recall them. claude-mem observations it marked sensitive are never
read. Codex's raw inputs (`raw_memories.md`, `rollout_summaries/`) are not
read either: they summarize sessions Orchestra already captures, and Codex
folds them into the files above.

## How it shows up

Every memory read from another tool keeps where it came from. When you or an
agent recall it, the citation names the tool and the exact place, for example
`CLAUDE.md:12 (Testing)`. If the same fact is written in two tools, recall
shows it once and cites both.

Secrets are removed before anything is sent, the same way they are for your
sessions.

## Keeping it in step

Connected sources are read again in the background when an agent session
starts. To read them now:

```bash theme={null}
orchestra sources sync
```

When you edit a line in the tool, the memory changes with it. When you delete
one, it stops being current. `orchestra doctor` shows when each source was last
read, whether anything went wrong, and whether the tool's version is newer or
older than the versions Orchestra was tested with.

## Stop reading a source

```bash theme={null}
orchestra sources disconnect cursor
```

Its memories stop being current in Orchestra. Its files are not touched.

## Move off a memory tool

If you are leaving a tool such as agentmemory or claude-mem, import its
memories once instead of keeping it connected:

```bash theme={null}
orchestra import agentmemory
```

It shows what it found and asks before reading anything. Each memory keeps its
citation to the tool and the record it came from, and stays in Orchestra after
you remove the tool. Running it again adds only what is new: nothing is
duplicated, and nothing you deleted in the tool since is removed here.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.